sys/dev/mlx/mlx.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999 Michael Smith
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  *      $FreeBSD$
  29  */
  30
  31 /*
  32  * Driver for the Mylex DAC960 family of RAID controllers.
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/bio.h>
  38 #include <sys/lock.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mutex.h>
  41 #include <sys/kernel.h>
  42 #include <sys/sx.h>
  43
  44 #include <sys/bus.h>
  45 #include <sys/conf.h>
  46 #include <sys/stat.h>
  47
  48 #include <machine/resource.h>
  49 #include <machine/bus.h>
  50 #include <machine/clock.h>
  51 #include <sys/rman.h>
  52
  53 #include <geom/geom_disk.h>
  54
  55 #include <dev/mlx/mlxio.h>
  56 #include <dev/mlx/mlxvar.h>
  57 #include <dev/mlx/mlxreg.h>
  58
  59 static struct cdevsw mlx_cdevsw = {
  60         .d_version =    D_VERSION,
  61         .d_open =       mlx_open,
  62         .d_close =      mlx_close,
  63         .d_ioctl =      mlx_ioctl,
  64         .d_name =       "mlx",
  65 };
  66
  67 devclass_t      mlx_devclass;
  68
  69 /*
  70  * Per-interface accessor methods
  71  */
  72 static int                      mlx_v3_tryqueue(struct mlx_softc *sc, struct mlx_command *mc);
  73 static int                      mlx_v3_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status);
  74 static void                     mlx_v3_intaction(struct mlx_softc *sc, int action);
  75 static int                      mlx_v3_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2, int first);
  76
  77 static int                      mlx_v4_tryqueue(struct mlx_softc *sc, struct mlx_command *mc);
  78 static int                      mlx_v4_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status);
  79 static void                     mlx_v4_intaction(struct mlx_softc *sc, int action);
  80 static int                      mlx_v4_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2, int first);
  81
  82 static int                      mlx_v5_tryqueue(struct mlx_softc *sc, struct mlx_command *mc);
  83 static int                      mlx_v5_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status);
  84 static void                     mlx_v5_intaction(struct mlx_softc *sc, int action);
  85 static int                      mlx_v5_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2, int first);
  86
  87 /*
  88  * Status monitoring
  89  */
  90 static void                     mlx_periodic(void *data);
  91 static void                     mlx_periodic_enquiry(struct mlx_command *mc);
  92 static void                     mlx_periodic_eventlog_poll(struct mlx_softc *sc);
  93 static void                     mlx_periodic_eventlog_respond(struct mlx_command *mc);
  94 static void                     mlx_periodic_rebuild(struct mlx_command *mc);
  95
  96 /*
  97  * Channel Pause
  98  */
  99 static void                     mlx_pause_action(struct mlx_softc *sc);
 100 static void                     mlx_pause_done(struct mlx_command *mc);
 101
 102 /*
 103  * Command submission.
 104  */
 105 static void                     *mlx_enquire(struct mlx_softc *sc, int command, size_t bufsize,
 106                                              void (*complete)(struct mlx_command *mc));
 107 static int                      mlx_flush(struct mlx_softc *sc);
 108 static int                      mlx_check(struct mlx_softc *sc, int drive);
 109 static int                      mlx_rebuild(struct mlx_softc *sc, int channel, int target);
 110 static int                      mlx_wait_command(struct mlx_command *mc);
 111 static int                      mlx_poll_command(struct mlx_command *mc);
 112 void                            mlx_startio_cb(void *arg,
 113                                                bus_dma_segment_t *segs,
 114                                                int nsegments, int error);
 115 static void                     mlx_startio(struct mlx_softc *sc);
 116 static void                     mlx_completeio(struct mlx_command *mc);
 117 static int                      mlx_user_command(struct mlx_softc *sc,
 118                                                  struct mlx_usercommand *mu);
 119 void                            mlx_user_cb(void *arg, bus_dma_segment_t *segs,
 120                                             int nsegments, int error);
 121
 122 /*
 123  * Command buffer allocation.
 124  */
 125 static struct mlx_command       *mlx_alloccmd(struct mlx_softc *sc);
 126 static void                     mlx_releasecmd(struct mlx_command *mc);
 127 static void                     mlx_freecmd(struct mlx_command *mc);
 128
 129 /*
 130  * Command management.
 131  */
 132 static int                      mlx_getslot(struct mlx_command *mc);
 133 static void                     mlx_setup_dmamap(struct mlx_command *mc,
 134                                                  bus_dma_segment_t *segs,
 135                                                  int nsegments, int error);
 136 static void                     mlx_unmapcmd(struct mlx_command *mc);
 137 static int                      mlx_shutdown_locked(struct mlx_softc *sc);
 138 static int                      mlx_start(struct mlx_command *mc);
 139 static int                      mlx_done(struct mlx_softc *sc, int startio);
 140 static void                     mlx_complete(struct mlx_softc *sc);
 141
 142 /*
 143  * Debugging.
 144  */
 145 static char                     *mlx_diagnose_command(struct mlx_command *mc);
 146 static void                     mlx_describe_controller(struct mlx_softc *sc);
 147 static int                      mlx_fw_message(struct mlx_softc *sc, int status, int param1, int param2);
 148
 149 /*
 150  * Utility functions.
 151  */
 152 static struct mlx_sysdrive      *mlx_findunit(struct mlx_softc *sc, int unit);
 153
 154 /********************************************************************************
 155  ********************************************************************************
 156                                                                 Public Interfaces
 157  ********************************************************************************
 158  ********************************************************************************/
 159
 160 /********************************************************************************
 161  * Free all of the resources associated with (sc)
 162  *
 163  * Should not be called if the controller is active.
 164  */
 165 void
 166 mlx_free(struct mlx_softc *sc)
 167 {
 168     struct mlx_command  *mc;
 169
 170     debug_called(1);
 171
 172     /* destroy control device */
 173     if (sc->mlx_dev_t != NULL)
 174         destroy_dev(sc->mlx_dev_t);
 175
 176     if (sc->mlx_intr)
 177         bus_teardown_intr(sc->mlx_dev, sc->mlx_irq, sc->mlx_intr);
 178
 179     /* cancel status timeout */
 180     MLX_IO_LOCK(sc);
 181     callout_stop(&sc->mlx_timeout);
 182
 183     /* throw away any command buffers */
 184     while ((mc = TAILQ_FIRST(&sc->mlx_freecmds)) != NULL) {
 185         TAILQ_REMOVE(&sc->mlx_freecmds, mc, mc_link);
 186         mlx_freecmd(mc);
 187     }
 188     MLX_IO_UNLOCK(sc);
 189     callout_drain(&sc->mlx_timeout);
 190
 191     /* destroy data-transfer DMA tag */
 192     if (sc->mlx_buffer_dmat)
 193         bus_dma_tag_destroy(sc->mlx_buffer_dmat);
 194
 195     /* free and destroy DMA memory and tag for s/g lists */
 196     if (sc->mlx_sgbusaddr)
 197         bus_dmamap_unload(sc->mlx_sg_dmat, sc->mlx_sg_dmamap);
 198     if (sc->mlx_sgtable)
 199         bus_dmamem_free(sc->mlx_sg_dmat, sc->mlx_sgtable, sc->mlx_sg_dmamap);
 200     if (sc->mlx_sg_dmat)
 201         bus_dma_tag_destroy(sc->mlx_sg_dmat);
 202
 203     /* disconnect the interrupt handler */
 204     if (sc->mlx_irq != NULL)
 205         bus_release_resource(sc->mlx_dev, SYS_RES_IRQ, 0, sc->mlx_irq);
 206
 207     /* destroy the parent DMA tag */
 208     if (sc->mlx_parent_dmat)
 209         bus_dma_tag_destroy(sc->mlx_parent_dmat);
 210
 211     /* release the register window mapping */
 212     if (sc->mlx_mem != NULL)
 213         bus_release_resource(sc->mlx_dev, sc->mlx_mem_type, sc->mlx_mem_rid, sc->mlx_mem);
 214
 215     /* free controller enquiry data */
 216     if (sc->mlx_enq2 != NULL)
 217         free(sc->mlx_enq2, M_DEVBUF);
 218
 219     sx_destroy(&sc->mlx_config_lock);
 220     mtx_destroy(&sc->mlx_io_lock);
 221 }
 222
 223 /********************************************************************************
 224  * Map the scatter/gather table into bus space
 225  */
 226 static void
 227 mlx_dma_map_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 228 {
 229     struct mlx_softc    *sc = (struct mlx_softc *)arg;
 230
 231     debug_called(1);
 232
 233     /* save base of s/g table's address in bus space */
 234     sc->mlx_sgbusaddr = segs->ds_addr;
 235 }
 236
 237 static int
 238 mlx_sglist_map(struct mlx_softc *sc)
 239 {
 240     size_t      segsize;
 241     int         error, ncmd;
 242
 243     debug_called(1);
 244
 245     /* destroy any existing mappings */
 246     if (sc->mlx_sgbusaddr)
 247         bus_dmamap_unload(sc->mlx_sg_dmat, sc->mlx_sg_dmamap);
 248     if (sc->mlx_sgtable)
 249         bus_dmamem_free(sc->mlx_sg_dmat, sc->mlx_sgtable, sc->mlx_sg_dmamap);
 250     if (sc->mlx_sg_dmat)
 251         bus_dma_tag_destroy(sc->mlx_sg_dmat);
 252     sc->mlx_sgbusaddr = 0;
 253     sc->mlx_sgtable = NULL;
 254     sc->mlx_sg_dmat = NULL;
 255
 256     /*
 257      * Create a single tag describing a region large enough to hold all of
 258      * the s/g lists we will need.  If we're called early on, we don't know how
 259      * many commands we're going to be asked to support, so only allocate enough
 260      * for a couple.
 261      */
 262     if (sc->mlx_enq2 == NULL) {
 263         ncmd = 2;
 264     } else {
 265         ncmd = sc->mlx_enq2->me_max_commands;
 266     }
 267     segsize = sizeof(struct mlx_sgentry) * MLX_NSEG * ncmd;
 268     error = bus_dma_tag_create(sc->mlx_parent_dmat,     /* parent */
 269                                1, 0,                    /* alignment,boundary */
 270                                BUS_SPACE_MAXADDR,       /* lowaddr */
 271                                BUS_SPACE_MAXADDR,       /* highaddr */
 272                                NULL, NULL,              /* filter, filterarg */
 273                                segsize, 1,              /* maxsize, nsegments */
 274                                BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
 275                                0,                       /* flags */
 276                                NULL, NULL,              /* lockfunc, lockarg */
 277                                &sc->mlx_sg_dmat);
 278     if (error != 0) {
 279         device_printf(sc->mlx_dev, "can't allocate scatter/gather DMA tag\n");
 280         return(ENOMEM);
 281     }
 282
 283     /*
 284      * Allocate enough s/g maps for all commands and permanently map them into
 285      * controller-visible space.
 286      *
 287      * XXX this assumes we can get enough space for all the s/g maps in one
 288      * contiguous slab.  We may need to switch to a more complex arrangement
 289      * where we allocate in smaller chunks and keep a lookup table from slot
 290      * to bus address.
 291      */
 292     error = bus_dmamem_alloc(sc->mlx_sg_dmat, (void **)&sc->mlx_sgtable,
 293                              BUS_DMA_NOWAIT, &sc->mlx_sg_dmamap);
 294     if (error) {
 295         device_printf(sc->mlx_dev, "can't allocate s/g table\n");
 296         return(ENOMEM);
 297     }
 298     (void)bus_dmamap_load(sc->mlx_sg_dmat, sc->mlx_sg_dmamap, sc->mlx_sgtable,
 299                           segsize, mlx_dma_map_sg, sc, 0);
 300     return(0);
 301 }
 302
 303 /********************************************************************************
 304  * Initialise the controller and softc
 305  */
 306 int
 307 mlx_attach(struct mlx_softc *sc)
 308 {
 309     struct mlx_enquiry_old      *meo;
 310     int                         rid, error, fwminor, hscode, hserror, hsparam1, hsparam2, hsmsg;
 311
 312     debug_called(1);
 313
 314     /*
 315      * Initialise per-controller queues.
 316      */
 317     TAILQ_INIT(&sc->mlx_work);
 318     TAILQ_INIT(&sc->mlx_freecmds);
 319     bioq_init(&sc->mlx_bioq);
 320
 321     /*
 322      * Select accessor methods based on controller interface type.
 323      */
 324     switch(sc->mlx_iftype) {
 325     case MLX_IFTYPE_2:
 326     case MLX_IFTYPE_3:
 327         sc->mlx_tryqueue        = mlx_v3_tryqueue;
 328         sc->mlx_findcomplete    = mlx_v3_findcomplete;
 329         sc->mlx_intaction       = mlx_v3_intaction;
 330         sc->mlx_fw_handshake    = mlx_v3_fw_handshake;
 331         break;
 332     case MLX_IFTYPE_4:
 333         sc->mlx_tryqueue        = mlx_v4_tryqueue;
 334         sc->mlx_findcomplete    = mlx_v4_findcomplete;
 335         sc->mlx_intaction       = mlx_v4_intaction;
 336         sc->mlx_fw_handshake    = mlx_v4_fw_handshake;
 337         break;
 338     case MLX_IFTYPE_5:
 339         sc->mlx_tryqueue        = mlx_v5_tryqueue;
 340         sc->mlx_findcomplete    = mlx_v5_findcomplete;
 341         sc->mlx_intaction       = mlx_v5_intaction;
 342         sc->mlx_fw_handshake    = mlx_v5_fw_handshake;
 343         break;
 344     default:
 345         return(ENXIO);          /* should never happen */
 346     }
 347
 348     /* disable interrupts before we start talking to the controller */
 349     MLX_IO_LOCK(sc);
 350     sc->mlx_intaction(sc, MLX_INTACTION_DISABLE);
 351     MLX_IO_UNLOCK(sc);
 352
 353     /*
 354      * Wait for the controller to come ready, handshake with the firmware if required.
 355      * This is typically only necessary on platforms where the controller BIOS does not
 356      * run.
 357      */
 358     hsmsg = 0;
 359     DELAY(1000);
 360     while ((hscode = sc->mlx_fw_handshake(sc, &hserror, &hsparam1, &hsparam2,
 361         hsmsg == 0)) != 0) {
 362         /* report first time around... */
 363         if (hsmsg == 0) {
 364             device_printf(sc->mlx_dev, "controller initialisation in progress...\n");
 365             hsmsg = 1;
 366         }
 367         /* did we get a real message? */
 368         if (hscode == 2) {
 369             hscode = mlx_fw_message(sc, hserror, hsparam1, hsparam2);
 370             /* fatal initialisation error? */
 371             if (hscode != 0) {
 372                 return(ENXIO);
 373             }
 374         }
 375     }
 376     if (hsmsg == 1)
 377         device_printf(sc->mlx_dev, "initialisation complete.\n");
 378
 379     /*
 380      * Allocate and connect our interrupt.
 381      */
 382     rid = 0;
 383     sc->mlx_irq = bus_alloc_resource_any(sc->mlx_dev, SYS_RES_IRQ, &rid,
 384         RF_SHAREABLE | RF_ACTIVE);
 385     if (sc->mlx_irq == NULL) {
 386         device_printf(sc->mlx_dev, "can't allocate interrupt\n");
 387         return(ENXIO);
 388     }
 389     error = bus_setup_intr(sc->mlx_dev, sc->mlx_irq, INTR_TYPE_BIO |
 390         INTR_ENTROPY | INTR_MPSAFE, NULL, mlx_intr, sc, &sc->mlx_intr);
 391     if (error) {
 392         device_printf(sc->mlx_dev, "can't set up interrupt\n");
 393         return(ENXIO);
 394     }
 395
 396     /*
 397      * Create DMA tag for mapping buffers into controller-addressable space.
 398      */
 399     error = bus_dma_tag_create(sc->mlx_parent_dmat,     /* parent */
 400                                1, 0,                    /* align, boundary */
 401                                BUS_SPACE_MAXADDR,       /* lowaddr */
 402                                BUS_SPACE_MAXADDR,       /* highaddr */
 403                                NULL, NULL,              /* filter, filterarg */
 404                                MLX_MAXPHYS,             /* maxsize */
 405                                MLX_NSEG,                /* nsegments */
 406                                BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
 407                                0,                       /* flags */
 408                                busdma_lock_mutex,       /* lockfunc */
 409                                &sc->mlx_io_lock,        /* lockarg */
 410                                &sc->mlx_buffer_dmat);
 411     if (error != 0) {
 412         device_printf(sc->mlx_dev, "can't allocate buffer DMA tag\n");
 413         return(ENOMEM);
 414     }
 415
 416     /*
 417      * Create some initial scatter/gather mappings so we can run the probe
 418      * commands.
 419      */
 420     error = mlx_sglist_map(sc);
 421     if (error != 0) {
 422         device_printf(sc->mlx_dev, "can't make initial s/g list mapping\n");
 423         return(error);
 424     }
 425
 426     /*
 427      * We don't (yet) know where the event log is up to.
 428      */
 429     sc->mlx_currevent = -1;
 430
 431     /*
 432      * Obtain controller feature information
 433      */
 434     MLX_IO_LOCK(sc);
 435     if ((sc->mlx_enq2 = mlx_enquire(sc, MLX_CMD_ENQUIRY2, sizeof(struct mlx_enquiry2), NULL)) == NULL) {
 436         MLX_IO_UNLOCK(sc);
 437         device_printf(sc->mlx_dev, "ENQUIRY2 failed\n");
 438         return(ENXIO);
 439     }
 440
 441     /*
 442      * Do quirk/feature related things.
 443      */
 444     fwminor = (sc->mlx_enq2->me_firmware_id >> 8) & 0xff;
 445     switch(sc->mlx_iftype) {
 446     case MLX_IFTYPE_2:
 447         /* These controllers don't report the firmware version in the ENQUIRY2 response */
 448         if ((meo = mlx_enquire(sc, MLX_CMD_ENQUIRY_OLD, sizeof(struct mlx_enquiry_old), NULL)) == NULL) {
 449             MLX_IO_UNLOCK(sc);
 450             device_printf(sc->mlx_dev, "ENQUIRY_OLD failed\n");
 451             return(ENXIO);
 452         }
 453         sc->mlx_enq2->me_firmware_id = ('0' << 24) | (0 << 16) | (meo->me_fwminor << 8) | meo->me_fwmajor;
 454
 455         /* XXX require 2.42 or better (PCI) */
 456         if (meo->me_fwminor < 42) {
 457             device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
 458             device_printf(sc->mlx_dev, " *** WARNING *** Use revision 2.42 or later\n");
 459         }
 460         free(meo, M_DEVBUF);
 461         break;
 462     case MLX_IFTYPE_3:
 463         /* XXX certify 3.52? */
 464         if (fwminor < 51) {
 465             device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
 466             device_printf(sc->mlx_dev, " *** WARNING *** Use revision 3.51 or later\n");
 467         }
 468         break;
 469     case MLX_IFTYPE_4:
 470         /* XXX certify firmware versions? */
 471         if (fwminor < 6) {
 472             device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
 473             device_printf(sc->mlx_dev, " *** WARNING *** Use revision 4.06 or later\n");
 474         }
 475         break;
 476     case MLX_IFTYPE_5:
 477         if (fwminor < 7) {
 478             device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
 479             device_printf(sc->mlx_dev, " *** WARNING *** Use revision 5.07 or later\n");
 480         }
 481         break;
 482     default:
 483         MLX_IO_UNLOCK(sc);
 484         return(ENXIO);          /* should never happen */
 485     }
 486     MLX_IO_UNLOCK(sc);
 487
 488     /*
 489      * Create the final scatter/gather mappings now that we have characterised the controller.
 490      */
 491     error = mlx_sglist_map(sc);
 492     if (error != 0) {
 493         device_printf(sc->mlx_dev, "can't make final s/g list mapping\n");
 494         return(error);
 495     }
 496
 497     /*
 498      * No user-requested background operation is in progress.
 499      */
 500     sc->mlx_background = 0;
 501     sc->mlx_rebuildstat.rs_code = MLX_REBUILDSTAT_IDLE;
 502
 503     /*
 504      * Create the control device.
 505      */
 506     sc->mlx_dev_t = make_dev(&mlx_cdevsw, 0, UID_ROOT, GID_OPERATOR,
 507                              S_IRUSR | S_IWUSR, "mlx%d", device_get_unit(sc->mlx_dev));
 508     sc->mlx_dev_t->si_drv1 = sc;
 509
 510     /*
 511      * Start the timeout routine.
 512      */
 513     callout_reset(&sc->mlx_timeout, hz, mlx_periodic, sc);
 514
 515     /* print a little information about the controller */
 516     mlx_describe_controller(sc);
 517
 518     return(0);
 519 }
 520
 521 /********************************************************************************
 522  * Locate disk resources and attach children to them.
 523  */
 524 void
 525 mlx_startup(struct mlx_softc *sc)
 526 {
 527     struct mlx_enq_sys_drive    *mes;
 528     struct mlx_sysdrive         *dr;
 529     int                         i, error;
 530
 531     debug_called(1);
 532
 533     /*
 534      * Scan all the system drives and attach children for those that
 535      * don't currently have them.
 536      */
 537     MLX_IO_LOCK(sc);
 538     mes = mlx_enquire(sc, MLX_CMD_ENQSYSDRIVE, sizeof(*mes) * MLX_MAXDRIVES, NULL);
 539     MLX_IO_UNLOCK(sc);
 540     if (mes == NULL) {
 541         device_printf(sc->mlx_dev, "error fetching drive status\n");
 542         return;
 543     }
 544
 545     /* iterate over drives returned */
 546     MLX_CONFIG_LOCK(sc);
 547     for (i = 0, dr = &sc->mlx_sysdrive[0];
 548          (i < MLX_MAXDRIVES) && (mes[i].sd_size != 0xffffffff);
 549          i++, dr++) {
 550         /* are we already attached to this drive? */
 551         if (dr->ms_disk == 0) {
 552             /* pick up drive information */
 553             dr->ms_size = mes[i].sd_size;
 554             dr->ms_raidlevel = mes[i].sd_raidlevel & 0xf;
 555             dr->ms_state = mes[i].sd_state;
 556
 557             /* generate geometry information */
 558             if (sc->mlx_geom == MLX_GEOM_128_32) {
 559                 dr->ms_heads = 128;
 560                 dr->ms_sectors = 32;
 561                 dr->ms_cylinders = dr->ms_size / (128 * 32);
 562             } else {        /* MLX_GEOM_255/63 */
 563                 dr->ms_heads = 255;
 564                 dr->ms_sectors = 63;
 565                 dr->ms_cylinders = dr->ms_size / (255 * 63);
 566             }
 567             dr->ms_disk =  device_add_child(sc->mlx_dev, /*"mlxd"*/NULL, -1);
 568             if (dr->ms_disk == 0)
 569                 device_printf(sc->mlx_dev, "device_add_child failed\n");
 570             device_set_ivars(dr->ms_disk, dr);
 571         }
 572     }
 573     free(mes, M_DEVBUF);
 574     if ((error = bus_generic_attach(sc->mlx_dev)) != 0)
 575         device_printf(sc->mlx_dev, "bus_generic_attach returned %d", error);
 576
 577     /* mark controller back up */
 578     MLX_IO_LOCK(sc);
 579     sc->mlx_state &= ~MLX_STATE_SHUTDOWN;
 580
 581     /* enable interrupts */
 582     sc->mlx_intaction(sc, MLX_INTACTION_ENABLE);
 583     MLX_IO_UNLOCK(sc);
 584     MLX_CONFIG_UNLOCK(sc);
 585 }
 586
 587 /********************************************************************************
 588  * Disconnect from the controller completely, in preparation for unload.
 589  */
 590 int
 591 mlx_detach(device_t dev)
 592 {
 593     struct mlx_softc    *sc = device_get_softc(dev);
 594     struct mlxd_softc   *mlxd;
 595     int                 i, error;
 596
 597     debug_called(1);
 598
 599     error = EBUSY;
 600     MLX_CONFIG_LOCK(sc);
 601     if (sc->mlx_state & MLX_STATE_OPEN)
 602         goto out;
 603
 604     for (i = 0; i < MLX_MAXDRIVES; i++) {
 605         if (sc->mlx_sysdrive[i].ms_disk != 0) {
 606             mlxd = device_get_softc(sc->mlx_sysdrive[i].ms_disk);
 607             if (mlxd->mlxd_flags & MLXD_OPEN) {         /* drive is mounted, abort detach */
 608                 device_printf(sc->mlx_sysdrive[i].ms_disk, "still open, can't detach\n");
 609                 goto out;
 610             }
 611         }
 612     }
 613     if ((error = mlx_shutdown(dev)))
 614         goto out;
 615     MLX_CONFIG_UNLOCK(sc);
 616
 617     mlx_free(sc);
 618
 619     return (0);
 620  out:
 621     MLX_CONFIG_UNLOCK(sc);
 622     return(error);
 623 }
 624
 625 /********************************************************************************
 626  * Bring the controller down to a dormant state and detach all child devices.
 627  *
 628  * This function is called before detach, system shutdown, or before performing
 629  * an operation which may add or delete system disks.  (Call mlx_startup to
 630  * resume normal operation.)
 631  *
 632  * Note that we can assume that the bioq on the controller is empty, as we won't
 633  * allow shutdown if any device is open.
 634  */
 635 int
 636 mlx_shutdown(device_t dev)
 637 {
 638     struct mlx_softc    *sc = device_get_softc(dev);
 639     int                 error;
 640
 641     MLX_CONFIG_LOCK(sc);
 642     error = mlx_shutdown_locked(sc);
 643     MLX_CONFIG_UNLOCK(sc);
 644     return (error);
 645 }
 646
 647 static int
 648 mlx_shutdown_locked(struct mlx_softc *sc)
 649 {
 650     int                 i, error;
 651
 652     debug_called(1);
 653
 654     MLX_CONFIG_ASSERT_LOCKED(sc);
 655
 656     MLX_IO_LOCK(sc);
 657     sc->mlx_state |= MLX_STATE_SHUTDOWN;
 658     sc->mlx_intaction(sc, MLX_INTACTION_DISABLE);
 659
 660     /* flush controller */
 661     device_printf(sc->mlx_dev, "flushing cache...");
 662     if (mlx_flush(sc)) {
 663         printf("failed\n");
 664     } else {
 665         printf("done\n");
 666     }
 667     MLX_IO_UNLOCK(sc);
 668
 669     /* delete all our child devices */
 670     for (i = 0; i < MLX_MAXDRIVES; i++) {
 671         if (sc->mlx_sysdrive[i].ms_disk != 0) {
 672             if ((error = device_delete_child(sc->mlx_dev, sc->mlx_sysdrive[i].ms_disk)) != 0)
 673                 return (error);
 674             sc->mlx_sysdrive[i].ms_disk = 0;
 675         }
 676     }
 677
 678     return (0);
 679 }
 680
 681 /********************************************************************************
 682  * Bring the controller to a quiescent state, ready for system suspend.
 683  */
 684 int
 685 mlx_suspend(device_t dev)
 686 {
 687     struct mlx_softc    *sc = device_get_softc(dev);
 688
 689     debug_called(1);
 690
 691     MLX_IO_LOCK(sc);
 692     sc->mlx_state |= MLX_STATE_SUSPEND;
 693
 694     /* flush controller */
 695     device_printf(sc->mlx_dev, "flushing cache...");
 696     printf("%s\n", mlx_flush(sc) ? "failed" : "done");
 697
 698     sc->mlx_intaction(sc, MLX_INTACTION_DISABLE);
 699     MLX_IO_UNLOCK(sc);
 700
 701     return(0);
 702 }
 703
 704 /********************************************************************************
 705  * Bring the controller back to a state ready for operation.
 706  */
 707 int
 708 mlx_resume(device_t dev)
 709 {
 710     struct mlx_softc    *sc = device_get_softc(dev);
 711
 712     debug_called(1);
 713
 714     MLX_IO_LOCK(sc);
 715     sc->mlx_state &= ~MLX_STATE_SUSPEND;
 716     sc->mlx_intaction(sc, MLX_INTACTION_ENABLE);
 717     MLX_IO_UNLOCK(sc);
 718
 719     return(0);
 720 }
 721
 722 /*******************************************************************************
 723  * Take an interrupt, or be poked by other code to look for interrupt-worthy
 724  * status.
 725  */
 726 void
 727 mlx_intr(void *arg)
 728 {
 729     struct mlx_softc    *sc = (struct mlx_softc *)arg;
 730
 731     debug_called(1);
 732
 733     /* collect finished commands, queue anything waiting */
 734     MLX_IO_LOCK(sc);
 735     mlx_done(sc, 1);
 736     MLX_IO_UNLOCK(sc);
 737 };
 738
 739 /*******************************************************************************
 740  * Receive a buf structure from a child device and queue it on a particular
 741  * disk resource, then poke the disk resource to start as much work as it can.
 742  */
 743 int
 744 mlx_submit_buf(struct mlx_softc *sc, struct bio *bp)
 745 {
 746
 747     debug_called(1);
 748
 749     MLX_IO_ASSERT_LOCKED(sc);
 750     bioq_insert_tail(&sc->mlx_bioq, bp);
 751     sc->mlx_waitbufs++;
 752     mlx_startio(sc);
 753     return(0);
 754 }
 755
 756 /********************************************************************************
 757  * Accept an open operation on the control device.
 758  */
 759 int
 760 mlx_open(struct cdev *dev, int flags, int fmt, struct thread *td)
 761 {
 762     struct mlx_softc    *sc = dev->si_drv1;
 763
 764     MLX_CONFIG_LOCK(sc);
 765     MLX_IO_LOCK(sc);
 766     sc->mlx_state |= MLX_STATE_OPEN;
 767     MLX_IO_UNLOCK(sc);
 768     MLX_CONFIG_UNLOCK(sc);
 769     return(0);
 770 }
 771
 772 /********************************************************************************
 773  * Accept the last close on the control device.
 774  */
 775 int
 776 mlx_close(struct cdev *dev, int flags, int fmt, struct thread *td)
 777 {
 778     struct mlx_softc    *sc = dev->si_drv1;
 779
 780     MLX_CONFIG_LOCK(sc);
 781     MLX_IO_LOCK(sc);
 782     sc->mlx_state &= ~MLX_STATE_OPEN;
 783     MLX_IO_UNLOCK(sc);
 784     MLX_CONFIG_UNLOCK(sc);
 785     return (0);
 786 }
 787
 788 /********************************************************************************
 789  * Handle controller-specific control operations.
 790  */
 791 int
 792 mlx_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td)
 793 {
 794     struct mlx_softc            *sc = dev->si_drv1;
 795     struct mlx_rebuild_request  *rb = (struct mlx_rebuild_request *)addr;
 796     struct mlx_rebuild_status   *rs = (struct mlx_rebuild_status *)addr;
 797     int                         *arg = (int *)addr;
 798     struct mlx_pause            *mp;
 799     struct mlx_sysdrive         *dr;
 800     struct mlxd_softc           *mlxd;
 801     int                         i, error;
 802
 803     switch(cmd) {
 804         /*
 805          * Enumerate connected system drives; returns the first system drive's
 806          * unit number if *arg is -1, or the next unit after *arg if it's
 807          * a valid unit on this controller.
 808          */
 809     case MLX_NEXT_CHILD:
 810         /* search system drives */
 811         MLX_CONFIG_LOCK(sc);
 812         for (i = 0; i < MLX_MAXDRIVES; i++) {
 813             /* is this one attached? */
 814             if (sc->mlx_sysdrive[i].ms_disk != 0) {
 815                 /* looking for the next one we come across? */
 816                 if (*arg == -1) {
 817                     *arg = device_get_unit(sc->mlx_sysdrive[i].ms_disk);
 818                     MLX_CONFIG_UNLOCK(sc);
 819                     return(0);
 820                 }
 821                 /* we want the one after this one */
 822                 if (*arg == device_get_unit(sc->mlx_sysdrive[i].ms_disk))
 823                     *arg = -1;
 824             }
 825         }
 826         MLX_CONFIG_UNLOCK(sc);
 827         return(ENOENT);
 828
 829         /*
 830          * Scan the controller to see whether new drives have appeared.
 831          */
 832     case MLX_RESCAN_DRIVES:
 833         mtx_lock(&Giant);
 834         mlx_startup(sc);
 835         mtx_unlock(&Giant);
 836         return(0);
 837
 838         /*
 839          * Disconnect from the specified drive; it may be about to go
 840          * away.
 841          */
 842     case MLX_DETACH_DRIVE:                      /* detach one drive */
 843         MLX_CONFIG_LOCK(sc);
 844         if (((dr = mlx_findunit(sc, *arg)) == NULL) ||
 845             ((mlxd = device_get_softc(dr->ms_disk)) == NULL)) {
 846             MLX_CONFIG_UNLOCK(sc);
 847             return(ENOENT);
 848         }
 849
 850         device_printf(dr->ms_disk, "detaching...");
 851         error = 0;
 852         if (mlxd->mlxd_flags & MLXD_OPEN) {
 853             error = EBUSY;
 854             goto detach_out;
 855         }
 856
 857         /* flush controller */
 858         MLX_IO_LOCK(sc);
 859         if (mlx_flush(sc)) {
 860             MLX_IO_UNLOCK(sc);
 861             error = EBUSY;
 862             goto detach_out;
 863         }
 864         MLX_IO_UNLOCK(sc);
 865
 866         /* nuke drive */
 867         if ((error = device_delete_child(sc->mlx_dev, dr->ms_disk)) != 0)
 868             goto detach_out;
 869         dr->ms_disk = 0;
 870
 871     detach_out:
 872         MLX_CONFIG_UNLOCK(sc);
 873         if (error) {
 874             printf("failed\n");
 875         } else {
 876             printf("done\n");
 877         }
 878         return(error);
 879
 880         /*
 881          * Pause one or more SCSI channels for a period of time, to assist
 882          * in the process of hot-swapping devices.
 883          *
 884          * Note that at least the 3.51 firmware on the DAC960PL doesn't seem
 885          * to do this right.
 886          */
 887     case MLX_PAUSE_CHANNEL:                     /* schedule a channel pause */
 888         /* Does this command work on this firmware? */
 889         if (!(sc->mlx_feature & MLX_FEAT_PAUSEWORKS))
 890             return(EOPNOTSUPP);
 891
 892         /* check time values */
 893         mp = (struct mlx_pause *)addr;
 894         if ((mp->mp_when < 0) || (mp->mp_when > 3600))
 895             return(EINVAL);
 896         if ((mp->mp_howlong < 1) || (mp->mp_howlong > (0xf * 30)))
 897             return(EINVAL);
 898
 899         MLX_IO_LOCK(sc);
 900         if ((mp->mp_which == MLX_PAUSE_CANCEL) && (sc->mlx_pause.mp_when != 0)) {
 901             /* cancel a pending pause operation */
 902             sc->mlx_pause.mp_which = 0;
 903         } else {
 904             /* fix for legal channels */
 905             mp->mp_which &= ((1 << sc->mlx_enq2->me_actual_channels) -1);
 906
 907             /* check for a pause currently running */
 908             if ((sc->mlx_pause.mp_which != 0) && (sc->mlx_pause.mp_when == 0)) {
 909                 MLX_IO_UNLOCK(sc);
 910                 return(EBUSY);
 911             }
 912
 913             /* looks ok, go with it */
 914             sc->mlx_pause.mp_which = mp->mp_which;
 915             sc->mlx_pause.mp_when = time_second + mp->mp_when;
 916             sc->mlx_pause.mp_howlong = sc->mlx_pause.mp_when + mp->mp_howlong;
 917         }
 918         MLX_IO_UNLOCK(sc);
 919         return(0);
 920
 921         /*
 922          * Accept a command passthrough-style.
 923          */
 924     case MLX_COMMAND:
 925         return(mlx_user_command(sc, (struct mlx_usercommand *)addr));
 926
 927         /*
 928          * Start a rebuild on a given SCSI disk
 929          */
 930     case MLX_REBUILDASYNC:
 931         MLX_IO_LOCK(sc);
 932         if (sc->mlx_background != 0) {
 933             MLX_IO_UNLOCK(sc);
 934             rb->rr_status = 0x0106;
 935             return(EBUSY);
 936         }
 937         rb->rr_status = mlx_rebuild(sc, rb->rr_channel, rb->rr_target);
 938         switch (rb->rr_status) {
 939         case 0:
 940             error = 0;
 941             break;
 942         case 0x10000:
 943             error = ENOMEM;             /* couldn't set up the command */
 944             break;
 945         case 0x0002:
 946             error = EBUSY;
 947             break;
 948         case 0x0104:
 949             error = EIO;
 950             break;
 951         case 0x0105:
 952             error = ERANGE;
 953             break;
 954         case 0x0106:
 955             error = EBUSY;
 956             break;
 957         default:
 958             error = EINVAL;
 959             break;
 960         }
 961         if (error == 0)
 962             sc->mlx_background = MLX_BACKGROUND_REBUILD;
 963         MLX_IO_UNLOCK(sc);
 964         return(error);
 965
 966         /*
 967          * Get the status of the current rebuild or consistency check.
 968          */
 969     case MLX_REBUILDSTAT:
 970         MLX_IO_LOCK(sc);
 971         *rs = sc->mlx_rebuildstat;
 972         MLX_IO_UNLOCK(sc);
 973         return(0);
 974
 975         /*
 976          * Return the per-controller system drive number matching the
 977          * disk device number in (arg), if it happens to belong to us.
 978          */
 979     case MLX_GET_SYSDRIVE:
 980         error = ENOENT;
 981         MLX_CONFIG_LOCK(sc);
 982         mtx_lock(&Giant);
 983         mlxd = (struct mlxd_softc *)devclass_get_softc(mlxd_devclass, *arg);
 984         mtx_unlock(&Giant);
 985         if ((mlxd != NULL) && (mlxd->mlxd_drive >= sc->mlx_sysdrive) &&
 986             (mlxd->mlxd_drive < (sc->mlx_sysdrive + MLX_MAXDRIVES))) {
 987             error = 0;
 988             *arg = mlxd->mlxd_drive - sc->mlx_sysdrive;
 989         }
 990         MLX_CONFIG_UNLOCK(sc);
 991         return(error);
 992
 993     default:
 994         return(ENOTTY);
 995     }
 996 }
 997
 998 /********************************************************************************
 999  * Handle operations requested by a System Drive connected to this controller.
1000  */
1001 int
1002 mlx_submit_ioctl(struct mlx_softc *sc, struct mlx_sysdrive *drive, u_long cmd,
1003                 caddr_t addr, int32_t flag, struct thread *td)
1004 {
1005     int                         *arg = (int *)addr;
1006     int                         error, result;
1007
1008     switch(cmd) {
1009         /*
1010          * Return the current status of this drive.
1011          */
1012     case MLXD_STATUS:
1013         MLX_IO_LOCK(sc);
1014         *arg = drive->ms_state;
1015         MLX_IO_UNLOCK(sc);
1016         return(0);
1017
1018         /*
1019          * Start a background consistency check on this drive.
1020          */
1021     case MLXD_CHECKASYNC:               /* start a background consistency check */
1022         MLX_IO_LOCK(sc);
1023         if (sc->mlx_background != 0) {
1024             MLX_IO_UNLOCK(sc);
1025             *arg = 0x0106;
1026             return(EBUSY);
1027         }
1028         result = mlx_check(sc, drive - &sc->mlx_sysdrive[0]);
1029         switch (result) {
1030         case 0:
1031             error = 0;
1032             break;
1033         case 0x10000:
1034             error = ENOMEM;             /* couldn't set up the command */
1035             break;
1036         case 0x0002:
1037             error = EIO;
1038             break;
1039         case 0x0105:
1040             error = ERANGE;
1041             break;
1042         case 0x0106:
1043             error = EBUSY;
1044             break;
1045         default:
1046             error = EINVAL;
1047             break;
1048         }
1049         if (error == 0)
1050             sc->mlx_background = MLX_BACKGROUND_CHECK;
1051         MLX_IO_UNLOCK(sc);
1052         *arg = result;
1053         return(error);
1054
1055     }
1056     return(ENOIOCTL);
1057 }
1058
1059
1060 /********************************************************************************
1061  ********************************************************************************
1062                                                                 Status Monitoring
1063  ********************************************************************************
1064  ********************************************************************************/
1065
1066 /********************************************************************************
1067  * Fire off commands to periodically check the status of connected drives.
1068  */
1069 static void
1070 mlx_periodic(void *data)
1071 {
1072     struct mlx_softc *sc = (struct mlx_softc *)data;
1073
1074     debug_called(1);
1075     MLX_IO_ASSERT_LOCKED(sc);
1076
1077     /*
1078      * Run a bus pause?
1079      */
1080     if ((sc->mlx_pause.mp_which != 0) &&
1081         (sc->mlx_pause.mp_when > 0) &&
1082         (time_second >= sc->mlx_pause.mp_when)){
1083
1084         mlx_pause_action(sc);           /* pause is running */
1085         sc->mlx_pause.mp_when = 0;
1086         sysbeep(500, hz);
1087
1088         /*
1089          * Bus pause still running?
1090          */
1091     } else if ((sc->mlx_pause.mp_which != 0) &&
1092                (sc->mlx_pause.mp_when == 0)) {
1093
1094         /* time to stop bus pause? */
1095         if (time_second >= sc->mlx_pause.mp_howlong) {
1096             mlx_pause_action(sc);
1097             sc->mlx_pause.mp_which = 0; /* pause is complete */
1098             sysbeep(500, hz);
1099         } else {
1100             sysbeep((time_second % 5) * 100 + 500, hz/8);
1101         }
1102
1103         /*
1104          * Run normal periodic activities?
1105          */
1106     } else if (time_second > (sc->mlx_lastpoll + 10)) {
1107         sc->mlx_lastpoll = time_second;
1108
1109         /*
1110          * Check controller status.
1111          *
1112          * XXX Note that this may not actually launch a command in situations of high load.
1113          */
1114         mlx_enquire(sc, (sc->mlx_iftype == MLX_IFTYPE_2) ? MLX_CMD_ENQUIRY_OLD : MLX_CMD_ENQUIRY,
1115                     imax(sizeof(struct mlx_enquiry), sizeof(struct mlx_enquiry_old)), mlx_periodic_enquiry);
1116
1117         /*
1118          * Check system drive status.
1119          *
1120          * XXX This might be better left to event-driven detection, eg. I/O to an offline
1121          *     drive will detect it's offline, rebuilds etc. should detect the drive is back
1122          *     online.
1123          */
1124         mlx_enquire(sc, MLX_CMD_ENQSYSDRIVE, sizeof(struct mlx_enq_sys_drive) * MLX_MAXDRIVES,
1125                         mlx_periodic_enquiry);
1126
1127     }
1128
1129     /* get drive rebuild/check status */
1130     /* XXX should check sc->mlx_background if this is only valid while in progress */
1131     mlx_enquire(sc, MLX_CMD_REBUILDSTAT, sizeof(struct mlx_rebuild_stat), mlx_periodic_rebuild);
1132
1133     /* deal with possibly-missed interrupts and timed-out commands */
1134     mlx_done(sc, 1);
1135
1136     /* reschedule another poll next second or so */
1137     callout_reset(&sc->mlx_timeout, hz, mlx_periodic, sc);
1138 }
1139
1140 /********************************************************************************
1141  * Handle the result of an ENQUIRY command instigated by periodic status polling.
1142  */
1143 static void
1144 mlx_periodic_enquiry(struct mlx_command *mc)
1145 {
1146     struct mlx_softc            *sc = mc->mc_sc;
1147
1148     debug_called(1);
1149     MLX_IO_ASSERT_LOCKED(sc);
1150
1151     /* Command completed OK? */
1152     if (mc->mc_status != 0) {
1153         device_printf(sc->mlx_dev, "periodic enquiry failed - %s\n", mlx_diagnose_command(mc));
1154         goto out;
1155     }
1156
1157     /* respond to command */
1158     switch(mc->mc_mailbox[0]) {
1159         /*
1160          * This is currently a bit fruitless, as we don't know how to extract the eventlog
1161          * pointer yet.
1162          */
1163     case MLX_CMD_ENQUIRY_OLD:
1164     {
1165         struct mlx_enquiry              *me = (struct mlx_enquiry *)mc->mc_data;
1166         struct mlx_enquiry_old          *meo = (struct mlx_enquiry_old *)mc->mc_data;
1167         int                             i;
1168
1169         /* convert data in-place to new format */
1170         for (i = (sizeof(me->me_dead) / sizeof(me->me_dead[0])) - 1; i >= 0; i--) {
1171             me->me_dead[i].dd_chan = meo->me_dead[i].dd_chan;
1172             me->me_dead[i].dd_targ = meo->me_dead[i].dd_targ;
1173         }
1174         me->me_misc_flags        = 0;
1175         me->me_rebuild_count     = meo->me_rebuild_count;
1176         me->me_dead_count        = meo->me_dead_count;
1177         me->me_critical_sd_count = meo->me_critical_sd_count;
1178         me->me_event_log_seq_num = 0;
1179         me->me_offline_sd_count  = meo->me_offline_sd_count;
1180         me->me_max_commands      = meo->me_max_commands;
1181         me->me_rebuild_flag      = meo->me_rebuild_flag;
1182         me->me_fwmajor           = meo->me_fwmajor;
1183         me->me_fwminor           = meo->me_fwminor;
1184         me->me_status_flags      = meo->me_status_flags;
1185         me->me_flash_age         = meo->me_flash_age;
1186         for (i = (sizeof(me->me_drvsize) / sizeof(me->me_drvsize[0])) - 1; i >= 0; i--) {
1187             if (i > ((sizeof(meo->me_drvsize) / sizeof(meo->me_drvsize[0])) - 1)) {
1188                 me->me_drvsize[i] = 0;          /* drive beyond supported range */
1189             } else {
1190                 me->me_drvsize[i] = meo->me_drvsize[i];
1191             }
1192         }
1193         me->me_num_sys_drvs = meo->me_num_sys_drvs;
1194     }
1195     /* FALLTHROUGH */
1196
1197         /*
1198          * Generic controller status update.  We could do more with this than just
1199          * checking the event log.
1200          */
1201     case MLX_CMD_ENQUIRY:
1202     {
1203         struct mlx_enquiry              *me = (struct mlx_enquiry *)mc->mc_data;
1204
1205         if (sc->mlx_currevent == -1) {
1206             /* initialise our view of the event log */
1207             sc->mlx_currevent = sc->mlx_lastevent = me->me_event_log_seq_num;
1208         } else if ((me->me_event_log_seq_num != sc->mlx_lastevent) && !(sc->mlx_flags & MLX_EVENTLOG_BUSY)) {
1209             /* record where current events are up to */
1210             sc->mlx_currevent = me->me_event_log_seq_num;
1211             debug(1, "event log pointer was %d, now %d\n", sc->mlx_lastevent, sc->mlx_currevent);
1212
1213             /* mark the event log as busy */
1214             sc->mlx_flags |= MLX_EVENTLOG_BUSY;
1215
1216             /* drain new eventlog entries */
1217             mlx_periodic_eventlog_poll(sc);
1218         }
1219         break;
1220     }
1221     case MLX_CMD_ENQSYSDRIVE:
1222     {
1223         struct mlx_enq_sys_drive        *mes = (struct mlx_enq_sys_drive *)mc->mc_data;
1224         struct mlx_sysdrive             *dr;
1225         int                             i;
1226
1227         for (i = 0, dr = &sc->mlx_sysdrive[0];
1228              (i < MLX_MAXDRIVES) && (mes[i].sd_size != 0xffffffff);
1229              i++) {
1230
1231             /* has state been changed by controller? */
1232             if (dr->ms_state != mes[i].sd_state) {
1233                 switch(mes[i].sd_state) {
1234                 case MLX_SYSD_OFFLINE:
1235                     device_printf(dr->ms_disk, "drive offline\n");
1236                     break;
1237                 case MLX_SYSD_ONLINE:
1238                     device_printf(dr->ms_disk, "drive online\n");
1239                     break;
1240                 case MLX_SYSD_CRITICAL:
1241                     device_printf(dr->ms_disk, "drive critical\n");
1242                     break;
1243                 }
1244                 /* save new state */
1245                 dr->ms_state = mes[i].sd_state;
1246             }
1247         }
1248         break;
1249     }
1250     default:
1251         device_printf(sc->mlx_dev, "%s: unknown command 0x%x", __func__, mc->mc_mailbox[0]);
1252         break;
1253     }
1254
1255  out:
1256     free(mc->mc_data, M_DEVBUF);
1257     mlx_releasecmd(mc);
1258 }
1259
1260 static void
1261 mlx_eventlog_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1262 {
1263     struct mlx_command *mc;
1264
1265     mc = (struct mlx_command *)arg;
1266     mlx_setup_dmamap(mc, segs, nsegments, error);
1267
1268     /* build the command to get one entry */
1269     mlx_make_type3(mc, MLX_CMD_LOGOP, MLX_LOGOP_GET, 1,
1270                    mc->mc_sc->mlx_lastevent, 0, 0, mc->mc_dataphys, 0);
1271     mc->mc_complete = mlx_periodic_eventlog_respond;
1272     mc->mc_private = mc;
1273
1274     /* start the command */
1275     if (mlx_start(mc) != 0) {
1276         mlx_releasecmd(mc);
1277         free(mc->mc_data, M_DEVBUF);
1278         mc->mc_data = NULL;
1279     }
1280
1281 }
1282
1283 /********************************************************************************
1284  * Instigate a poll for one event log message on (sc).
1285  * We only poll for one message at a time, to keep our command usage down.
1286  */
1287 static void
1288 mlx_periodic_eventlog_poll(struct mlx_softc *sc)
1289 {
1290     struct mlx_command  *mc;
1291     void                *result = NULL;
1292     int                 error = 0;
1293
1294     debug_called(1);
1295     MLX_IO_ASSERT_LOCKED(sc);
1296
1297     /* get ourselves a command buffer */
1298     error = 1;
1299     if ((mc = mlx_alloccmd(sc)) == NULL)
1300         goto out;
1301
1302     /* allocate the response structure */
1303     if ((result = malloc(/*sizeof(struct mlx_eventlog_entry)*/1024, M_DEVBUF,
1304                          M_NOWAIT)) == NULL)
1305         goto out;
1306
1307     /* get a command slot */
1308     if (mlx_getslot(mc))
1309         goto out;
1310
1311     /* map the command so the controller can see it */
1312     mc->mc_data = result;
1313     mc->mc_length = /*sizeof(struct mlx_eventlog_entry)*/1024;
1314     error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
1315                             mc->mc_length, mlx_eventlog_cb, mc, BUS_DMA_NOWAIT);
1316
1317  out:
1318     if (error != 0) {
1319         if (mc != NULL)
1320             mlx_releasecmd(mc);
1321         if ((result != NULL) && (mc->mc_data != NULL))
1322             free(result, M_DEVBUF);
1323     }
1324 }
1325
1326 /********************************************************************************
1327  * Handle the result of polling for a log message, generate diagnostic output.
1328  * If this wasn't the last message waiting for us, we'll go collect another.
1329  */
1330 static char *mlx_sense_messages[] = {
1331     "because write recovery failed",
1332     "because of SCSI bus reset failure",
1333     "because of double check condition",
1334     "because it was removed",
1335     "because of gross error on SCSI chip",
1336     "because of bad tag returned from drive",
1337     "because of timeout on SCSI command",
1338     "because of reset SCSI command issued from system",
1339     "because busy or parity error count exceeded limit",
1340     "because of 'kill drive' command from system",
1341     "because of selection timeout",
1342     "due to SCSI phase sequence error",
1343     "due to unknown status"
1344 };
1345
1346 static void
1347 mlx_periodic_eventlog_respond(struct mlx_command *mc)
1348 {
1349     struct mlx_softc            *sc = mc->mc_sc;
1350     struct mlx_eventlog_entry   *el = (struct mlx_eventlog_entry *)mc->mc_data;
1351     char                        *reason;
1352
1353     debug_called(1);
1354     MLX_IO_ASSERT_LOCKED(sc);
1355
1356     sc->mlx_lastevent++;                /* next message... */
1357     if (mc->mc_status == 0) {
1358
1359         /* handle event log message */
1360         switch(el->el_type) {
1361             /*
1362              * This is the only sort of message we understand at the moment.
1363              * The tests here are probably incomplete.
1364              */
1365         case MLX_LOGMSG_SENSE:  /* sense data */
1366             /* Mylex vendor-specific message indicating a drive was killed? */
1367             if ((el->el_sensekey == 9) &&
1368                 (el->el_asc == 0x80)) {
1369                 if (el->el_asq < nitems(mlx_sense_messages)) {
1370                     reason = mlx_sense_messages[el->el_asq];
1371                 } else {
1372                     reason = "for unknown reason";
1373                 }
1374                 device_printf(sc->mlx_dev, "physical drive %d:%d killed %s\n",
1375                               el->el_channel, el->el_target, reason);
1376             }
1377             /* SCSI drive was reset? */
1378             if ((el->el_sensekey == 6) && (el->el_asc == 0x29)) {
1379                 device_printf(sc->mlx_dev, "physical drive %d:%d reset\n",
1380                               el->el_channel, el->el_target);
1381             }
1382             /* SCSI drive error? */
1383             if (!((el->el_sensekey == 0) ||
1384                   ((el->el_sensekey == 2) &&
1385                    (el->el_asc == 0x04) &&
1386                    ((el->el_asq == 0x01) ||
1387                     (el->el_asq == 0x02))))) {
1388                 device_printf(sc->mlx_dev, "physical drive %d:%d error log: sense = %d asc = %x asq = %x\n",
1389                               el->el_channel, el->el_target, el->el_sensekey, el->el_asc, el->el_asq);
1390                 device_printf(sc->mlx_dev, "  info %4D csi %4D\n", el->el_information, ":", el->el_csi, ":");
1391             }
1392             break;
1393
1394         default:
1395             device_printf(sc->mlx_dev, "unknown log message type 0x%x\n", el->el_type);
1396             break;
1397         }
1398     } else {
1399         device_printf(sc->mlx_dev, "error reading message log - %s\n", mlx_diagnose_command(mc));
1400         /* give up on all the outstanding messages, as we may have come unsynched */
1401         sc->mlx_lastevent = sc->mlx_currevent;
1402     }
1403
1404     /* dispose of command and data */
1405     free(mc->mc_data, M_DEVBUF);
1406     mlx_releasecmd(mc);
1407
1408     /* is there another message to obtain? */
1409     if (sc->mlx_lastevent != sc->mlx_currevent) {
1410         mlx_periodic_eventlog_poll(sc);
1411     } else {
1412         /* clear log-busy status */
1413         sc->mlx_flags &= ~MLX_EVENTLOG_BUSY;
1414     }
1415 }
1416
1417 /********************************************************************************
1418  * Handle check/rebuild operations in progress.
1419  */
1420 static void
1421 mlx_periodic_rebuild(struct mlx_command *mc)
1422 {
1423     struct mlx_softc            *sc = mc->mc_sc;
1424     struct mlx_rebuild_status   *mr = (struct mlx_rebuild_status *)mc->mc_data;
1425
1426     MLX_IO_ASSERT_LOCKED(sc);
1427     switch(mc->mc_status) {
1428     case 0:                             /* operation running, update stats */
1429         sc->mlx_rebuildstat = *mr;
1430
1431         /* spontaneous rebuild/check? */
1432         if (sc->mlx_background == 0) {
1433             sc->mlx_background = MLX_BACKGROUND_SPONTANEOUS;
1434             device_printf(sc->mlx_dev, "background check/rebuild operation started\n");
1435         }
1436         break;
1437
1438     case 0x0105:                        /* nothing running, finalise stats and report */
1439         switch(sc->mlx_background) {
1440         case MLX_BACKGROUND_CHECK:
1441             device_printf(sc->mlx_dev, "consistency check completed\n");        /* XXX print drive? */
1442             break;
1443         case MLX_BACKGROUND_REBUILD:
1444             device_printf(sc->mlx_dev, "drive rebuild completed\n");    /* XXX print channel/target? */
1445             break;
1446         case MLX_BACKGROUND_SPONTANEOUS:
1447         default:
1448             /* if we have previously been non-idle, report the transition */
1449             if (sc->mlx_rebuildstat.rs_code != MLX_REBUILDSTAT_IDLE) {
1450                 device_printf(sc->mlx_dev, "background check/rebuild operation completed\n");
1451             }
1452         }
1453         sc->mlx_background = 0;
1454         sc->mlx_rebuildstat.rs_code = MLX_REBUILDSTAT_IDLE;
1455         break;
1456     }
1457     free(mc->mc_data, M_DEVBUF);
1458     mlx_releasecmd(mc);
1459 }
1460
1461 /********************************************************************************
1462  ********************************************************************************
1463                                                                     Channel Pause
1464  ********************************************************************************
1465  ********************************************************************************/
1466
1467 /********************************************************************************
1468  * It's time to perform a channel pause action for (sc), either start or stop
1469  * the pause.
1470  */
1471 static void
1472 mlx_pause_action(struct mlx_softc *sc)
1473 {
1474     struct mlx_command  *mc;
1475     int                 failsafe, i, command;
1476
1477     MLX_IO_ASSERT_LOCKED(sc);
1478
1479     /* What are we doing here? */
1480     if (sc->mlx_pause.mp_when == 0) {
1481         command = MLX_CMD_STARTCHANNEL;
1482         failsafe = 0;
1483
1484     } else {
1485         command = MLX_CMD_STOPCHANNEL;
1486
1487         /*
1488          * Channels will always start again after the failsafe period,
1489          * which is specified in multiples of 30 seconds.
1490          * This constrains us to a maximum pause of 450 seconds.
1491          */
1492         failsafe = ((sc->mlx_pause.mp_howlong - time_second) + 5) / 30;
1493         if (failsafe > 0xf) {
1494             failsafe = 0xf;
1495             sc->mlx_pause.mp_howlong = time_second + (0xf * 30) - 5;
1496         }
1497     }
1498
1499     /* build commands for every channel requested */
1500     for (i = 0; i < sc->mlx_enq2->me_actual_channels; i++) {
1501         if ((1 << i) & sc->mlx_pause.mp_which) {
1502
1503             /* get ourselves a command buffer */
1504             if ((mc = mlx_alloccmd(sc)) == NULL)
1505                 goto fail;
1506             /* get a command slot */
1507             mc->mc_flags |= MLX_CMD_PRIORITY;
1508             if (mlx_getslot(mc))
1509                 goto fail;
1510
1511             /* build the command */
1512             mlx_make_type2(mc, command, (failsafe << 4) | i, 0, 0, 0, 0, 0, 0, 0);
1513             mc->mc_complete = mlx_pause_done;
1514             mc->mc_private = sc;                /* XXX not needed */
1515             if (mlx_start(mc))
1516                 goto fail;
1517             /* command submitted OK */
1518             return;
1519
1520         fail:
1521             device_printf(sc->mlx_dev, "%s failed for channel %d\n",
1522                           command == MLX_CMD_STOPCHANNEL ? "pause" : "resume", i);
1523             if (mc != NULL)
1524                 mlx_releasecmd(mc);
1525         }
1526     }
1527 }
1528
1529 static void
1530 mlx_pause_done(struct mlx_command *mc)
1531 {
1532     struct mlx_softc    *sc = mc->mc_sc;
1533     int                 command = mc->mc_mailbox[0];
1534     int                 channel = mc->mc_mailbox[2] & 0xf;
1535
1536     MLX_IO_ASSERT_LOCKED(sc);
1537     if (mc->mc_status != 0) {
1538         device_printf(sc->mlx_dev, "%s command failed - %s\n",
1539                       command == MLX_CMD_STOPCHANNEL ? "pause" : "resume", mlx_diagnose_command(mc));
1540     } else if (command == MLX_CMD_STOPCHANNEL) {
1541         device_printf(sc->mlx_dev, "channel %d pausing for %ld seconds\n",
1542                       channel, (long)(sc->mlx_pause.mp_howlong - time_second));
1543     } else {
1544         device_printf(sc->mlx_dev, "channel %d resuming\n", channel);
1545     }
1546     mlx_releasecmd(mc);
1547 }
1548
1549 /********************************************************************************
1550  ********************************************************************************
1551                                                                Command Submission
1552  ********************************************************************************
1553  ********************************************************************************/
1554
1555 static void
1556 mlx_enquire_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1557 {
1558     struct mlx_softc *sc;
1559     struct mlx_command *mc;
1560
1561     mc = (struct mlx_command *)arg;
1562     if (error)
1563         return;
1564
1565     mlx_setup_dmamap(mc, segs, nsegments, error);
1566
1567     /* build an enquiry command */
1568     sc = mc->mc_sc;
1569     mlx_make_type2(mc, mc->mc_command, 0, 0, 0, 0, 0, 0, mc->mc_dataphys, 0);
1570
1571     /* do we want a completion callback? */
1572     if (mc->mc_complete != NULL) {
1573         if ((error = mlx_start(mc)) != 0)
1574             return;
1575     } else {
1576         /* run the command in either polled or wait mode */
1577         if ((sc->mlx_state & MLX_STATE_INTEN) ? mlx_wait_command(mc) :
1578                                                 mlx_poll_command(mc))
1579             return;
1580
1581         /* command completed OK? */
1582         if (mc->mc_status != 0) {
1583             device_printf(sc->mlx_dev, "ENQUIRY failed - %s\n",
1584                           mlx_diagnose_command(mc));
1585             return;
1586         }
1587     }
1588 }
1589
1590 /********************************************************************************
1591  * Perform an Enquiry command using a type-3 command buffer and a return a single
1592  * linear result buffer.  If the completion function is specified, it will
1593  * be called with the completed command (and the result response will not be
1594  * valid until that point).  Otherwise, the command will either be busy-waited
1595  * for (interrupts not enabled), or slept for.
1596  */
1597 static void *
1598 mlx_enquire(struct mlx_softc *sc, int command, size_t bufsize, void (* complete)(struct mlx_command *mc))
1599 {
1600     struct mlx_command  *mc;
1601     void                *result;
1602     int                 error;
1603
1604     debug_called(1);
1605     MLX_IO_ASSERT_LOCKED(sc);
1606
1607     /* get ourselves a command buffer */
1608     error = 1;
1609     result = NULL;
1610     if ((mc = mlx_alloccmd(sc)) == NULL)
1611         goto out;
1612     /* allocate the response structure */
1613     if ((result = malloc(bufsize, M_DEVBUF, M_NOWAIT)) == NULL)
1614         goto out;
1615     /* get a command slot */
1616     mc->mc_flags |= MLX_CMD_PRIORITY | MLX_CMD_DATAOUT;
1617     if (mlx_getslot(mc))
1618         goto out;
1619
1620     /* map the command so the controller can see it */
1621     mc->mc_data = result;
1622     mc->mc_length = bufsize;
1623     mc->mc_command = command;
1624
1625     if (complete != NULL) {
1626         mc->mc_complete = complete;
1627         mc->mc_private = mc;
1628     }
1629
1630     error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
1631                             mc->mc_length, mlx_enquire_cb, mc, BUS_DMA_NOWAIT);
1632
1633  out:
1634     /* we got a command, but nobody else will free it */
1635     if ((mc != NULL) && (mc->mc_complete == NULL))
1636         mlx_releasecmd(mc);
1637     /* we got an error, and we allocated a result */
1638     if ((error != 0) && (result != NULL)) {
1639         free(result, M_DEVBUF);
1640         result = NULL;
1641     }
1642     return(result);
1643 }
1644
1645
1646 /********************************************************************************
1647  * Perform a Flush command on the nominated controller.
1648  *
1649  * May be called with interrupts enabled or disabled; will not return until
1650  * the flush operation completes or fails.
1651  */
1652 static int
1653 mlx_flush(struct mlx_softc *sc)
1654 {
1655     struct mlx_command  *mc;
1656     int                 error;
1657
1658     debug_called(1);
1659     MLX_IO_ASSERT_LOCKED(sc);
1660
1661     /* get ourselves a command buffer */
1662     error = 1;
1663     if ((mc = mlx_alloccmd(sc)) == NULL)
1664         goto out;
1665     /* get a command slot */
1666     if (mlx_getslot(mc))
1667         goto out;
1668
1669     /* build a flush command */
1670     mlx_make_type2(mc, MLX_CMD_FLUSH, 0, 0, 0, 0, 0, 0, 0, 0);
1671
1672     /* can't assume that interrupts are going to work here, so play it safe */
1673     if (mlx_poll_command(mc))
1674         goto out;
1675
1676     /* command completed OK? */
1677     if (mc->mc_status != 0) {
1678         device_printf(sc->mlx_dev, "FLUSH failed - %s\n", mlx_diagnose_command(mc));
1679         goto out;
1680     }
1681
1682     error = 0;                  /* success */
1683  out:
1684     if (mc != NULL)
1685         mlx_releasecmd(mc);
1686     return(error);
1687 }
1688
1689 /********************************************************************************
1690  * Start a background consistency check on (drive).
1691  *
1692  * May be called with interrupts enabled or disabled; will return as soon as the
1693  * operation has started or been refused.
1694  */
1695 static int
1696 mlx_check(struct mlx_softc *sc, int drive)
1697 {
1698     struct mlx_command  *mc;
1699     int                 error;
1700
1701     debug_called(1);
1702     MLX_IO_ASSERT_LOCKED(sc);
1703
1704     /* get ourselves a command buffer */
1705     error = 0x10000;
1706     if ((mc = mlx_alloccmd(sc)) == NULL)
1707         goto out;
1708     /* get a command slot */
1709     if (mlx_getslot(mc))
1710         goto out;
1711
1712     /* build a checkasync command, set the "fix it" flag */
1713     mlx_make_type2(mc, MLX_CMD_CHECKASYNC, 0, 0, 0, 0, 0, drive | 0x80, 0, 0);
1714
1715     /* start the command and wait for it to be returned */
1716     if (mlx_wait_command(mc))
1717         goto out;
1718
1719     /* command completed OK? */
1720     if (mc->mc_status != 0) {
1721         device_printf(sc->mlx_dev, "CHECK ASYNC failed - %s\n", mlx_diagnose_command(mc));
1722     } else {
1723         device_printf(sc->mlx_sysdrive[drive].ms_disk, "consistency check started");
1724     }
1725     error = mc->mc_status;
1726
1727  out:
1728     if (mc != NULL)
1729         mlx_releasecmd(mc);
1730     return(error);
1731 }
1732
1733 /********************************************************************************
1734  * Start a background rebuild of the physical drive at (channel),(target).
1735  *
1736  * May be called with interrupts enabled or disabled; will return as soon as the
1737  * operation has started or been refused.
1738  */
1739 static int
1740 mlx_rebuild(struct mlx_softc *sc, int channel, int target)
1741 {
1742     struct mlx_command  *mc;
1743     int                 error;
1744
1745     debug_called(1);
1746     MLX_IO_ASSERT_LOCKED(sc);
1747
1748     /* get ourselves a command buffer */
1749     error = 0x10000;
1750     if ((mc = mlx_alloccmd(sc)) == NULL)
1751         goto out;
1752     /* get a command slot */
1753     if (mlx_getslot(mc))
1754         goto out;
1755
1756     /* build a checkasync command, set the "fix it" flag */
1757     mlx_make_type2(mc, MLX_CMD_REBUILDASYNC, channel, target, 0, 0, 0, 0, 0, 0);
1758
1759     /* start the command and wait for it to be returned */
1760     if (mlx_wait_command(mc))
1761         goto out;
1762
1763     /* command completed OK? */
1764     if (mc->mc_status != 0) {
1765         device_printf(sc->mlx_dev, "REBUILD ASYNC failed - %s\n", mlx_diagnose_command(mc));
1766     } else {
1767         device_printf(sc->mlx_dev, "drive rebuild started for %d:%d\n", channel, target);
1768     }
1769     error = mc->mc_status;
1770
1771  out:
1772     if (mc != NULL)
1773         mlx_releasecmd(mc);
1774     return(error);
1775 }
1776
1777 /********************************************************************************
1778  * Run the command (mc) and return when it completes.
1779  *
1780  * Interrupts need to be enabled; returns nonzero on error.
1781  */
1782 static int
1783 mlx_wait_command(struct mlx_command *mc)
1784 {
1785     struct mlx_softc    *sc = mc->mc_sc;
1786     int                 error, count;
1787
1788     debug_called(1);
1789     MLX_IO_ASSERT_LOCKED(sc);
1790
1791     mc->mc_complete = NULL;
1792     mc->mc_private = mc;                /* wake us when you're done */
1793     if ((error = mlx_start(mc)) != 0)
1794         return(error);
1795
1796     count = 0;
1797     /* XXX better timeout? */
1798     while ((mc->mc_status == MLX_STATUS_BUSY) && (count < 30)) {
1799         mtx_sleep(mc->mc_private, &sc->mlx_io_lock, PRIBIO | PCATCH, "mlxwcmd", hz);
1800     }
1801
1802     if (mc->mc_status != 0) {
1803         device_printf(sc->mlx_dev, "command failed - %s\n", mlx_diagnose_command(mc));
1804         return(EIO);
1805     }
1806     return(0);
1807 }
1808
1809
1810 /********************************************************************************
1811  * Start the command (mc) and busy-wait for it to complete.
1812  *
1813  * Should only be used when interrupts can't be relied upon. Returns 0 on
1814  * success, nonzero on error.
1815  * Successfully completed commands are dequeued.
1816  */
1817 static int
1818 mlx_poll_command(struct mlx_command *mc)
1819 {
1820     struct mlx_softc    *sc = mc->mc_sc;
1821     int                 error, count;
1822
1823     debug_called(1);
1824     MLX_IO_ASSERT_LOCKED(sc);
1825
1826     mc->mc_complete = NULL;
1827     mc->mc_private = NULL;      /* we will poll for it */
1828     if ((error = mlx_start(mc)) != 0)
1829         return(error);
1830
1831     count = 0;
1832     do {
1833         /* poll for completion */
1834         mlx_done(mc->mc_sc, 1);
1835
1836     } while ((mc->mc_status == MLX_STATUS_BUSY) && (count++ < 15000000));
1837     if (mc->mc_status != MLX_STATUS_BUSY) {
1838         TAILQ_REMOVE(&sc->mlx_work, mc, mc_link);
1839         return(0);
1840     }
1841     device_printf(sc->mlx_dev, "command failed - %s\n", mlx_diagnose_command(mc));
1842     return(EIO);
1843 }
1844
1845 void
1846 mlx_startio_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1847 {
1848     struct mlx_command  *mc;
1849     struct mlxd_softc   *mlxd;
1850     struct mlx_softc    *sc;
1851     struct bio          *bp;
1852     int                 blkcount;
1853     int                 driveno;
1854     int                 cmd;
1855
1856     mc = (struct mlx_command *)arg;
1857     mlx_setup_dmamap(mc, segs, nsegments, error);
1858
1859     sc = mc->mc_sc;
1860     bp = mc->mc_private;
1861
1862     if (bp->bio_cmd == BIO_READ) {
1863         mc->mc_flags |= MLX_CMD_DATAIN;
1864         cmd = MLX_CMD_READSG;
1865     } else {
1866         mc->mc_flags |= MLX_CMD_DATAOUT;
1867         cmd = MLX_CMD_WRITESG;
1868     }
1869
1870     /* build a suitable I/O command (assumes 512-byte rounded transfers) */
1871     mlxd = bp->bio_disk->d_drv1;
1872     driveno = mlxd->mlxd_drive - sc->mlx_sysdrive;
1873     blkcount = howmany(bp->bio_bcount, MLX_BLKSIZE);
1874
1875     if ((bp->bio_pblkno + blkcount) > sc->mlx_sysdrive[driveno].ms_size)
1876         device_printf(sc->mlx_dev,
1877                       "I/O beyond end of unit (%lld,%d > %lu)\n",
1878                       (long long)bp->bio_pblkno, blkcount,
1879                       (u_long)sc->mlx_sysdrive[driveno].ms_size);
1880
1881     /*
1882      * Build the I/O command.  Note that the SG list type bits are set to zero,
1883      * denoting the format of SG list that we are using.
1884      */
1885     if (sc->mlx_iftype == MLX_IFTYPE_2) {
1886         mlx_make_type1(mc, (cmd == MLX_CMD_WRITESG) ? MLX_CMD_WRITESG_OLD :
1887                                                       MLX_CMD_READSG_OLD,
1888                        blkcount & 0xff,         /* xfer length low byte */
1889                        bp->bio_pblkno,          /* physical block number */
1890                        driveno,                 /* target drive number */
1891                        mc->mc_sgphys,           /* location of SG list */
1892                        mc->mc_nsgent & 0x3f);   /* size of SG list */
1893         } else {
1894         mlx_make_type5(mc, cmd,
1895                        blkcount & 0xff,         /* xfer length low byte */
1896                        (driveno << 3) | ((blkcount >> 8) & 0x07),
1897                                                 /* target+length high 3 bits */
1898                        bp->bio_pblkno,          /* physical block number */
1899                        mc->mc_sgphys,           /* location of SG list */
1900                        mc->mc_nsgent & 0x3f);   /* size of SG list */
1901     }
1902
1903     /* try to give command to controller */
1904     if (mlx_start(mc) != 0) {
1905         /* fail the command */
1906         mc->mc_status = MLX_STATUS_WEDGED;
1907         mlx_completeio(mc);
1908     }
1909
1910     sc->mlx_state &= ~MLX_STATE_QFROZEN;
1911 }
1912
1913 /********************************************************************************
1914  * Pull as much work off the softc's work queue as possible and give it to the
1915  * controller.  Leave a couple of slots free for emergencies.
1916  */
1917 static void
1918 mlx_startio(struct mlx_softc *sc)
1919 {
1920     struct mlx_command  *mc;
1921     struct bio          *bp;
1922     int                 error;
1923
1924     MLX_IO_ASSERT_LOCKED(sc);
1925
1926     /* spin until something prevents us from doing any work */
1927     for (;;) {
1928         if (sc->mlx_state & MLX_STATE_QFROZEN)
1929             break;
1930
1931         /* see if there's work to be done */
1932         if ((bp = bioq_first(&sc->mlx_bioq)) == NULL)
1933             break;
1934         /* get a command */
1935         if ((mc = mlx_alloccmd(sc)) == NULL)
1936             break;
1937         /* get a slot for the command */
1938         if (mlx_getslot(mc) != 0) {
1939             mlx_releasecmd(mc);
1940             break;
1941         }
1942         /* get the buf containing our work */
1943         bioq_remove(&sc->mlx_bioq, bp);
1944         sc->mlx_waitbufs--;
1945
1946         /* connect the buf to the command */
1947         mc->mc_complete = mlx_completeio;
1948         mc->mc_private = bp;
1949         mc->mc_data = bp->bio_data;
1950         mc->mc_length = bp->bio_bcount;
1951
1952         /* map the command so the controller can work with it */
1953         error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
1954                                 mc->mc_length, mlx_startio_cb, mc, 0);
1955         if (error == EINPROGRESS) {
1956             sc->mlx_state |= MLX_STATE_QFROZEN;
1957             break;
1958         }
1959     }
1960 }
1961
1962 /********************************************************************************
1963  * Handle completion of an I/O command.
1964  */
1965 static void
1966 mlx_completeio(struct mlx_command *mc)
1967 {
1968     struct mlx_softc    *sc = mc->mc_sc;
1969     struct bio          *bp = mc->mc_private;
1970     struct mlxd_softc   *mlxd = bp->bio_disk->d_drv1;
1971
1972     MLX_IO_ASSERT_LOCKED(sc);
1973     if (mc->mc_status != MLX_STATUS_OK) {       /* could be more verbose here? */
1974         bp->bio_error = EIO;
1975         bp->bio_flags |= BIO_ERROR;
1976
1977         switch(mc->mc_status) {
1978         case MLX_STATUS_RDWROFFLINE:            /* system drive has gone offline */
1979             device_printf(mlxd->mlxd_dev, "drive offline\n");
1980             /* should signal this with a return code */
1981             mlxd->mlxd_drive->ms_state = MLX_SYSD_OFFLINE;
1982             break;
1983
1984         default:                                /* other I/O error */
1985             device_printf(sc->mlx_dev, "I/O error - %s\n", mlx_diagnose_command(mc));
1986 #if 0
1987             device_printf(sc->mlx_dev, "  b_bcount %ld  blkcount %ld  b_pblkno %d\n",
1988                           bp->bio_bcount, bp->bio_bcount / MLX_BLKSIZE, bp->bio_pblkno);
1989             device_printf(sc->mlx_dev, "  %13D\n", mc->mc_mailbox, " ");
1990 #endif
1991             break;
1992         }
1993     }
1994     mlx_releasecmd(mc);
1995     mlxd_intr(bp);
1996 }
1997
1998 void
1999 mlx_user_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
2000 {
2001     struct mlx_usercommand *mu;
2002     struct mlx_command *mc;
2003     struct mlx_dcdb     *dcdb;
2004
2005     mc = (struct mlx_command *)arg;
2006     if (error)
2007         return;
2008
2009     mlx_setup_dmamap(mc, segs, nsegments, error);
2010
2011     mu = (struct mlx_usercommand *)mc->mc_private;
2012     dcdb = NULL;
2013
2014     /*
2015      * If this is a passthrough SCSI command, the DCDB is packed at the
2016      * beginning of the data area.  Fix up the DCDB to point to the correct
2017      * physical address and override any bufptr supplied by the caller since
2018      * we know what it's meant to be.
2019      */
2020     if (mc->mc_mailbox[0] == MLX_CMD_DIRECT_CDB) {
2021         dcdb = (struct mlx_dcdb *)mc->mc_data;
2022         dcdb->dcdb_physaddr = mc->mc_dataphys + sizeof(*dcdb);
2023         mu->mu_bufptr = 8;
2024     }
2025
2026     /*
2027      * If there's a data buffer, fix up the command's buffer pointer.
2028      */
2029     if (mu->mu_datasize > 0) {
2030         mc->mc_mailbox[mu->mu_bufptr    ] =  mc->mc_dataphys        & 0xff;
2031         mc->mc_mailbox[mu->mu_bufptr + 1] = (mc->mc_dataphys >> 8)  & 0xff;
2032         mc->mc_mailbox[mu->mu_bufptr + 2] = (mc->mc_dataphys >> 16) & 0xff;
2033         mc->mc_mailbox[mu->mu_bufptr + 3] = (mc->mc_dataphys >> 24) & 0xff;
2034     }
2035     debug(0, "command fixup");
2036
2037     /* submit the command and wait */
2038     if (mlx_wait_command(mc) != 0)
2039         return;
2040
2041 }
2042
2043 /********************************************************************************
2044  * Take a command from user-space and try to run it.
2045  *
2046  * XXX Note that this can't perform very much in the way of error checking, and
2047  *     as such, applications _must_ be considered trustworthy.
2048  * XXX Commands using S/G for data are not supported.
2049  */
2050 static int
2051 mlx_user_command(struct mlx_softc *sc, struct mlx_usercommand *mu)
2052 {
2053     struct mlx_command  *mc;
2054     void                *kbuf;
2055     int                 error;
2056
2057     debug_called(0);
2058
2059     kbuf = NULL;
2060     mc = NULL;
2061     error = ENOMEM;
2062
2063     /* get ourselves a command and copy in from user space */
2064     MLX_IO_LOCK(sc);
2065     if ((mc = mlx_alloccmd(sc)) == NULL) {
2066         MLX_IO_UNLOCK(sc);
2067         return(error);
2068     }
2069     bcopy(mu->mu_command, mc->mc_mailbox, sizeof(mc->mc_mailbox));
2070     debug(0, "got command buffer");
2071
2072     /*
2073      * if we need a buffer for data transfer, allocate one and copy in its
2074      * initial contents
2075      */
2076     if (mu->mu_datasize > 0) {
2077         if (mu->mu_datasize > MLX_MAXPHYS) {
2078             error = EINVAL;
2079             goto out;
2080         }
2081         MLX_IO_UNLOCK(sc);
2082         if (((kbuf = malloc(mu->mu_datasize, M_DEVBUF, M_WAITOK)) == NULL) ||
2083             (error = copyin(mu->mu_buf, kbuf, mu->mu_datasize))) {
2084             MLX_IO_LOCK(sc);
2085             goto out;
2086         }
2087         MLX_IO_LOCK(sc);
2088         debug(0, "got kernel buffer");
2089     }
2090
2091     /* get a command slot */
2092     if (mlx_getslot(mc))
2093         goto out;
2094     debug(0, "got a slot");
2095
2096     if (mu->mu_datasize > 0) {
2097
2098         /* range check the pointer to physical buffer address */
2099         if ((mu->mu_bufptr < 0) || (mu->mu_bufptr > (sizeof(mu->mu_command) -
2100                                                      sizeof(u_int32_t)))) {
2101             error = EINVAL;
2102             goto out;
2103         }
2104     }
2105
2106     /* map the command so the controller can see it */
2107     mc->mc_data = kbuf;
2108     mc->mc_length = mu->mu_datasize;
2109     mc->mc_private = mu;
2110     error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
2111                             mc->mc_length, mlx_user_cb, mc, BUS_DMA_NOWAIT);
2112     if (error)
2113         goto out;
2114
2115     /* copy out status and data */
2116     mu->mu_status = mc->mc_status;
2117     if (mu->mu_datasize > 0) {
2118         MLX_IO_UNLOCK(sc);
2119         error = copyout(kbuf, mu->mu_buf, mu->mu_datasize);
2120         MLX_IO_LOCK(sc);
2121     }
2122
2123  out:
2124     mlx_releasecmd(mc);
2125     MLX_IO_UNLOCK(sc);
2126     if (kbuf != NULL)
2127         free(kbuf, M_DEVBUF);
2128     return(error);
2129 }
2130
2131 /********************************************************************************
2132  ********************************************************************************
2133                                                         Command I/O to Controller
2134  ********************************************************************************
2135  ********************************************************************************/
2136
2137 /********************************************************************************
2138  * Find a free command slot for (mc).
2139  *
2140  * Don't hand out a slot to a normal-priority command unless there are at least
2141  * 4 slots free for priority commands.
2142  */
2143 static int
2144 mlx_getslot(struct mlx_command *mc)
2145 {
2146     struct mlx_softc    *sc = mc->mc_sc;
2147     int                 slot, limit;
2148
2149     debug_called(1);
2150
2151     MLX_IO_ASSERT_LOCKED(sc);
2152
2153     /*
2154      * Enforce slot-usage limit, if we have the required information.
2155      */
2156     if (sc->mlx_enq2 != NULL) {
2157         limit = sc->mlx_enq2->me_max_commands;
2158     } else {
2159         limit = 2;
2160     }
2161     if (sc->mlx_busycmds >= ((mc->mc_flags & MLX_CMD_PRIORITY) ? limit : limit - 4))
2162         return(EBUSY);
2163
2164     /*
2165      * Allocate an outstanding command slot
2166      *
2167      * XXX linear search is slow
2168      */
2169     for (slot = 0; slot < limit; slot++) {
2170         debug(2, "try slot %d", slot);
2171         if (sc->mlx_busycmd[slot] == NULL)
2172             break;
2173     }
2174     if (slot < limit) {
2175         sc->mlx_busycmd[slot] = mc;
2176         sc->mlx_busycmds++;
2177     }
2178
2179     /* out of slots? */
2180     if (slot >= limit)
2181         return(EBUSY);
2182
2183     debug(2, "got slot %d", slot);
2184     mc->mc_slot = slot;
2185     return(0);
2186 }
2187
2188 /********************************************************************************
2189  * Map/unmap (mc)'s data in the controller's addressable space.
2190  */
2191 static void
2192 mlx_setup_dmamap(struct mlx_command *mc, bus_dma_segment_t *segs, int nsegments,
2193                  int error)
2194 {
2195     struct mlx_softc    *sc = mc->mc_sc;
2196     struct mlx_sgentry  *sg;
2197     int                 i;
2198
2199     debug_called(1);
2200
2201     /* XXX should be unnecessary */
2202     if (sc->mlx_enq2 && (nsegments > sc->mlx_enq2->me_max_sg))
2203         panic("MLX: too many s/g segments (%d, max %d)", nsegments,
2204               sc->mlx_enq2->me_max_sg);
2205
2206     /* get base address of s/g table */
2207     sg = sc->mlx_sgtable + (mc->mc_slot * MLX_NSEG);
2208
2209     /* save s/g table information in command */
2210     mc->mc_nsgent = nsegments;
2211     mc->mc_sgphys = sc->mlx_sgbusaddr +
2212                    (mc->mc_slot * MLX_NSEG * sizeof(struct mlx_sgentry));
2213     mc->mc_dataphys = segs[0].ds_addr;
2214
2215     /* populate s/g table */
2216     for (i = 0; i < nsegments; i++, sg++) {
2217         sg->sg_addr = segs[i].ds_addr;
2218         sg->sg_count = segs[i].ds_len;
2219     }
2220
2221     /* Make sure the buffers are visible on the bus. */
2222     if (mc->mc_flags & MLX_CMD_DATAIN)
2223         bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap,
2224                         BUS_DMASYNC_PREREAD);
2225     if (mc->mc_flags & MLX_CMD_DATAOUT)
2226         bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap,
2227                         BUS_DMASYNC_PREWRITE);
2228 }
2229
2230 static void
2231 mlx_unmapcmd(struct mlx_command *mc)
2232 {
2233     struct mlx_softc    *sc = mc->mc_sc;
2234
2235     debug_called(1);
2236
2237     /* if the command involved data at all */
2238     if (mc->mc_data != NULL) {
2239
2240         if (mc->mc_flags & MLX_CMD_DATAIN)
2241             bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap, BUS_DMASYNC_POSTREAD);
2242         if (mc->mc_flags & MLX_CMD_DATAOUT)
2243             bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap, BUS_DMASYNC_POSTWRITE);
2244
2245         bus_dmamap_unload(sc->mlx_buffer_dmat, mc->mc_dmamap);
2246     }
2247 }
2248
2249 /********************************************************************************
2250  * Try to deliver (mc) to the controller.
2251  *
2252  * Can be called at any interrupt level, with or without interrupts enabled.
2253  */
2254 static int
2255 mlx_start(struct mlx_command *mc)
2256 {
2257     struct mlx_softc    *sc = mc->mc_sc;
2258     int                 i;
2259
2260     debug_called(1);
2261
2262     /* save the slot number as ident so we can handle this command when complete */
2263     mc->mc_mailbox[0x1] = mc->mc_slot;
2264
2265     /* mark the command as currently being processed */
2266     mc->mc_status = MLX_STATUS_BUSY;
2267
2268     /* set a default 60-second timeout  XXX tunable?  XXX not currently used */
2269     mc->mc_timeout = time_second + 60;
2270
2271     /* spin waiting for the mailbox */
2272     for (i = 100000; i > 0; i--) {
2273         if (sc->mlx_tryqueue(sc, mc)) {
2274             /* move command to work queue */
2275             TAILQ_INSERT_TAIL(&sc->mlx_work, mc, mc_link);
2276             return (0);
2277         } else if (i > 1)
2278             mlx_done(sc, 0);
2279     }
2280
2281     /*
2282      * We couldn't get the controller to take the command.  Revoke the slot
2283      * that the command was given and return it with a bad status.
2284      */
2285     sc->mlx_busycmd[mc->mc_slot] = NULL;
2286     device_printf(sc->mlx_dev, "controller wedged (not taking commands)\n");
2287     mc->mc_status = MLX_STATUS_WEDGED;
2288     mlx_complete(sc);
2289     return(EIO);
2290 }
2291
2292 /********************************************************************************
2293  * Poll the controller (sc) for completed commands.
2294  * Update command status and free slots for reuse.  If any slots were freed,
2295  * new commands may be posted.
2296  *
2297  * Returns nonzero if one or more commands were completed.
2298  */
2299 static int
2300 mlx_done(struct mlx_softc *sc, int startio)
2301 {
2302     struct mlx_command  *mc;
2303     int                 result;
2304     u_int8_t            slot;
2305     u_int16_t           status;
2306
2307     debug_called(2);
2308     MLX_IO_ASSERT_LOCKED(sc);
2309
2310     result = 0;
2311
2312     /* loop collecting completed commands */
2313     for (;;) {
2314         /* poll for a completed command's identifier and status */
2315         if (sc->mlx_findcomplete(sc, &slot, &status)) {
2316             result = 1;
2317             mc = sc->mlx_busycmd[slot];                 /* find command */
2318             if (mc != NULL) {                           /* paranoia */
2319                 if (mc->mc_status == MLX_STATUS_BUSY) {
2320                     mc->mc_status = status;             /* save status */
2321
2322                     /* free slot for reuse */
2323                     sc->mlx_busycmd[slot] = NULL;
2324                     sc->mlx_busycmds--;
2325                 } else {
2326                     device_printf(sc->mlx_dev, "duplicate done event for slot %d\n", slot);
2327                 }
2328             } else {
2329                 device_printf(sc->mlx_dev, "done event for nonbusy slot %d\n", slot);
2330             }
2331         } else {
2332             break;
2333         }
2334     }
2335
2336     /* if we've completed any commands, try posting some more */
2337     if (result && startio)
2338         mlx_startio(sc);
2339
2340     /* handle completion and timeouts */
2341     mlx_complete(sc);
2342
2343     return(result);
2344 }
2345
2346 /********************************************************************************
2347  * Perform post-completion processing for commands on (sc).
2348  */
2349 static void
2350 mlx_complete(struct mlx_softc *sc)
2351 {
2352     struct mlx_command  *mc, *nc;
2353
2354     debug_called(2);
2355     MLX_IO_ASSERT_LOCKED(sc);
2356
2357     /* scan the list of busy/done commands */
2358     mc = TAILQ_FIRST(&sc->mlx_work);
2359     while (mc != NULL) {
2360         nc = TAILQ_NEXT(mc, mc_link);
2361
2362         /* Command has been completed in some fashion */
2363         if (mc->mc_status != MLX_STATUS_BUSY) {
2364
2365             /* unmap the command's data buffer */
2366             mlx_unmapcmd(mc);
2367             /*
2368              * Does the command have a completion handler?
2369              */
2370             if (mc->mc_complete != NULL) {
2371                 /* remove from list and give to handler */
2372                 TAILQ_REMOVE(&sc->mlx_work, mc, mc_link);
2373                 mc->mc_complete(mc);
2374
2375                 /*
2376                  * Is there a sleeper waiting on this command?
2377                  */
2378             } else if (mc->mc_private != NULL) {        /* sleeping caller wants to know about it */
2379
2380                 /* remove from list and wake up sleeper */
2381                 TAILQ_REMOVE(&sc->mlx_work, mc, mc_link);
2382                 wakeup_one(mc->mc_private);
2383
2384                 /*
2385                  * Leave the command for a caller that's polling for it.
2386                  */
2387             } else {
2388             }
2389         }
2390         mc = nc;
2391     }
2392 }
2393
2394 /********************************************************************************
2395  ********************************************************************************
2396                                                         Command Buffer Management
2397  ********************************************************************************
2398  ********************************************************************************/
2399
2400 /********************************************************************************
2401  * Get a new command buffer.
2402  *
2403  * This may return NULL in low-memory cases.
2404  *
2405  * Note that using malloc() is expensive (the command buffer is << 1 page) but
2406  * necessary if we are to be a loadable module before the zone allocator is fixed.
2407  *
2408  * If possible, we recycle a command buffer that's been used before.
2409  *
2410  * XXX Note that command buffers are not cleaned out - it is the caller's
2411  *     responsibility to ensure that all required fields are filled in before
2412  *     using a buffer.
2413  */
2414 static struct mlx_command *
2415 mlx_alloccmd(struct mlx_softc *sc)
2416 {
2417     struct mlx_command  *mc;
2418     int                 error;
2419
2420     debug_called(1);
2421
2422     MLX_IO_ASSERT_LOCKED(sc);
2423     if ((mc = TAILQ_FIRST(&sc->mlx_freecmds)) != NULL)
2424         TAILQ_REMOVE(&sc->mlx_freecmds, mc, mc_link);
2425
2426     /* allocate a new command buffer? */
2427     if (mc == NULL) {
2428         mc = (struct mlx_command *)malloc(sizeof(*mc), M_DEVBUF, M_NOWAIT | M_ZERO);
2429         if (mc != NULL) {
2430             mc->mc_sc = sc;
2431             error = bus_dmamap_create(sc->mlx_buffer_dmat, 0, &mc->mc_dmamap);
2432             if (error) {
2433                 free(mc, M_DEVBUF);
2434                 return(NULL);
2435             }
2436         }
2437     }
2438     return(mc);
2439 }
2440
2441 /********************************************************************************
2442  * Release a command buffer for recycling.
2443  *
2444  * XXX It might be a good idea to limit the number of commands we save for reuse
2445  *     if it's shown that this list bloats out massively.
2446  */
2447 static void
2448 mlx_releasecmd(struct mlx_command *mc)
2449 {
2450
2451     debug_called(1);
2452
2453     MLX_IO_ASSERT_LOCKED(mc->mc_sc);
2454     TAILQ_INSERT_HEAD(&mc->mc_sc->mlx_freecmds, mc, mc_link);
2455 }
2456
2457 /********************************************************************************
2458  * Permanently discard a command buffer.
2459  */
2460 static void
2461 mlx_freecmd(struct mlx_command *mc)
2462 {
2463     struct mlx_softc    *sc = mc->mc_sc;
2464
2465     debug_called(1);
2466     bus_dmamap_destroy(sc->mlx_buffer_dmat, mc->mc_dmamap);
2467     free(mc, M_DEVBUF);
2468 }
2469
2470
2471 /********************************************************************************
2472  ********************************************************************************
2473                                                 Type 3 interface accessor methods
2474  ********************************************************************************
2475  ********************************************************************************/
2476
2477 /********************************************************************************
2478  * Try to give (mc) to the controller.  Returns 1 if successful, 0 on failure
2479  * (the controller is not ready to take a command).
2480  */
2481 static int
2482 mlx_v3_tryqueue(struct mlx_softc *sc, struct mlx_command *mc)
2483 {
2484     int         i;
2485
2486     debug_called(2);
2487     MLX_IO_ASSERT_LOCKED(sc);
2488
2489     /* ready for our command? */
2490     if (!(MLX_V3_GET_IDBR(sc) & MLX_V3_IDB_FULL)) {
2491         /* copy mailbox data to window */
2492         for (i = 0; i < 13; i++)
2493             MLX_V3_PUT_MAILBOX(sc, i, mc->mc_mailbox[i]);
2494
2495         /* post command */
2496         MLX_V3_PUT_IDBR(sc, MLX_V3_IDB_FULL);
2497         return(1);
2498     }
2499     return(0);
2500 }
2501
2502 /********************************************************************************
2503  * See if a command has been completed, if so acknowledge its completion
2504  * and recover the slot number and status code.
2505  */
2506 static int
2507 mlx_v3_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status)
2508 {
2509
2510     debug_called(2);
2511     MLX_IO_ASSERT_LOCKED(sc);
2512
2513     /* status available? */
2514     if (MLX_V3_GET_ODBR(sc) & MLX_V3_ODB_SAVAIL) {
2515         *slot = MLX_V3_GET_STATUS_IDENT(sc);            /* get command identifier */
2516         *status = MLX_V3_GET_STATUS(sc);                /* get status */
2517
2518         /* acknowledge completion */
2519         MLX_V3_PUT_ODBR(sc, MLX_V3_ODB_SAVAIL);
2520         MLX_V3_PUT_IDBR(sc, MLX_V3_IDB_SACK);
2521         return(1);
2522     }
2523     return(0);
2524 }
2525
2526 /********************************************************************************
2527  * Enable/disable interrupts as requested. (No acknowledge required)
2528  */
2529 static void
2530 mlx_v3_intaction(struct mlx_softc *sc, int action)
2531 {
2532     debug_called(1);
2533     MLX_IO_ASSERT_LOCKED(sc);
2534
2535     switch(action) {
2536     case MLX_INTACTION_DISABLE:
2537         MLX_V3_PUT_IER(sc, 0);
2538         sc->mlx_state &= ~MLX_STATE_INTEN;
2539         break;
2540     case MLX_INTACTION_ENABLE:
2541         MLX_V3_PUT_IER(sc, 1);
2542         sc->mlx_state |= MLX_STATE_INTEN;
2543         break;
2544     }
2545 }
2546
2547 /********************************************************************************
2548  * Poll for firmware error codes during controller initialisation.
2549  * Returns 0 if initialisation is complete, 1 if still in progress but no
2550  * error has been fetched, 2 if an error has been retrieved.
2551  */
2552 static int
2553 mlx_v3_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2,
2554     int first)
2555 {
2556     u_int8_t    fwerror;
2557
2558     debug_called(2);
2559
2560     /* first time around, clear any hardware completion status */
2561     if (first) {
2562         MLX_V3_PUT_IDBR(sc, MLX_V3_IDB_SACK);
2563         DELAY(1000);
2564     }
2565
2566     /* init in progress? */
2567     if (!(MLX_V3_GET_IDBR(sc) & MLX_V3_IDB_INIT_BUSY))
2568         return(0);
2569
2570     /* test error value */
2571     fwerror = MLX_V3_GET_FWERROR(sc);
2572     if (!(fwerror & MLX_V3_FWERROR_PEND))
2573         return(1);
2574
2575     /* mask status pending bit, fetch status */
2576     *error = fwerror & ~MLX_V3_FWERROR_PEND;
2577     *param1 = MLX_V3_GET_FWERROR_PARAM1(sc);
2578     *param2 = MLX_V3_GET_FWERROR_PARAM2(sc);
2579
2580     /* acknowledge */
2581     MLX_V3_PUT_FWERROR(sc, 0);
2582
2583     return(2);
2584 }
2585
2586 /********************************************************************************
2587  ********************************************************************************
2588                                                 Type 4 interface accessor methods
2589  ********************************************************************************
2590  ********************************************************************************/
2591
2592 /********************************************************************************
2593  * Try to give (mc) to the controller.  Returns 1 if successful, 0 on failure
2594  * (the controller is not ready to take a command).
2595  */
2596 static int
2597 mlx_v4_tryqueue(struct mlx_softc *sc, struct mlx_command *mc)
2598 {
2599     int         i;
2600
2601     debug_called(2);
2602     MLX_IO_ASSERT_LOCKED(sc);
2603
2604     /* ready for our command? */
2605     if (!(MLX_V4_GET_IDBR(sc) & MLX_V4_IDB_FULL)) {
2606         /* copy mailbox data to window */
2607         for (i = 0; i < 13; i++)
2608             MLX_V4_PUT_MAILBOX(sc, i, mc->mc_mailbox[i]);
2609
2610         /* memory-mapped controller, so issue a write barrier to ensure the mailbox is filled */
2611         bus_barrier(sc->mlx_mem, MLX_V4_MAILBOX, MLX_V4_MAILBOX_LENGTH,
2612                           BUS_SPACE_BARRIER_WRITE);
2613
2614         /* post command */
2615         MLX_V4_PUT_IDBR(sc, MLX_V4_IDB_HWMBOX_CMD);
2616         return(1);
2617     }
2618     return(0);
2619 }
2620
2621 /********************************************************************************
2622  * See if a command has been completed, if so acknowledge its completion
2623  * and recover the slot number and status code.
2624  */
2625 static int
2626 mlx_v4_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status)
2627 {
2628
2629     debug_called(2);
2630     MLX_IO_ASSERT_LOCKED(sc);
2631
2632     /* status available? */
2633     if (MLX_V4_GET_ODBR(sc) & MLX_V4_ODB_HWSAVAIL) {
2634         *slot = MLX_V4_GET_STATUS_IDENT(sc);            /* get command identifier */
2635         *status = MLX_V4_GET_STATUS(sc);                /* get status */
2636
2637         /* acknowledge completion */
2638         MLX_V4_PUT_ODBR(sc, MLX_V4_ODB_HWMBOX_ACK);
2639         MLX_V4_PUT_IDBR(sc, MLX_V4_IDB_SACK);
2640         return(1);
2641     }
2642     return(0);
2643 }
2644
2645 /********************************************************************************
2646  * Enable/disable interrupts as requested.
2647  */
2648 static void
2649 mlx_v4_intaction(struct mlx_softc *sc, int action)
2650 {
2651     debug_called(1);
2652     MLX_IO_ASSERT_LOCKED(sc);
2653
2654     switch(action) {
2655     case MLX_INTACTION_DISABLE:
2656         MLX_V4_PUT_IER(sc, MLX_V4_IER_MASK | MLX_V4_IER_DISINT);
2657         sc->mlx_state &= ~MLX_STATE_INTEN;
2658         break;
2659     case MLX_INTACTION_ENABLE:
2660         MLX_V4_PUT_IER(sc, MLX_V4_IER_MASK & ~MLX_V4_IER_DISINT);
2661         sc->mlx_state |= MLX_STATE_INTEN;
2662         break;
2663     }
2664 }
2665
2666 /********************************************************************************
2667  * Poll for firmware error codes during controller initialisation.
2668  * Returns 0 if initialisation is complete, 1 if still in progress but no
2669  * error has been fetched, 2 if an error has been retrieved.
2670  */
2671 static int
2672 mlx_v4_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2,
2673     int first)
2674 {
2675     u_int8_t    fwerror;
2676
2677     debug_called(2);
2678
2679     /* first time around, clear any hardware completion status */
2680     if (first) {
2681         MLX_V4_PUT_IDBR(sc, MLX_V4_IDB_SACK);
2682         DELAY(1000);
2683     }
2684
2685     /* init in progress? */
2686     if (!(MLX_V4_GET_IDBR(sc) & MLX_V4_IDB_INIT_BUSY))
2687         return(0);
2688
2689     /* test error value */
2690     fwerror = MLX_V4_GET_FWERROR(sc);
2691     if (!(fwerror & MLX_V4_FWERROR_PEND))
2692         return(1);
2693
2694     /* mask status pending bit, fetch status */
2695     *error = fwerror & ~MLX_V4_FWERROR_PEND;
2696     *param1 = MLX_V4_GET_FWERROR_PARAM1(sc);
2697     *param2 = MLX_V4_GET_FWERROR_PARAM2(sc);
2698
2699     /* acknowledge */
2700     MLX_V4_PUT_FWERROR(sc, 0);
2701
2702     return(2);
2703 }
2704
2705 /********************************************************************************
2706  ********************************************************************************
2707                                                 Type 5 interface accessor methods
2708  ********************************************************************************
2709  ********************************************************************************/
2710
2711 /********************************************************************************
2712  * Try to give (mc) to the controller.  Returns 1 if successful, 0 on failure
2713  * (the controller is not ready to take a command).
2714  */
2715 static int
2716 mlx_v5_tryqueue(struct mlx_softc *sc, struct mlx_command *mc)
2717 {
2718     int         i;
2719
2720     debug_called(2);
2721     MLX_IO_ASSERT_LOCKED(sc);
2722
2723     /* ready for our command? */
2724     if (MLX_V5_GET_IDBR(sc) & MLX_V5_IDB_EMPTY) {
2725         /* copy mailbox data to window */
2726         for (i = 0; i < 13; i++)
2727             MLX_V5_PUT_MAILBOX(sc, i, mc->mc_mailbox[i]);
2728
2729         /* post command */
2730         MLX_V5_PUT_IDBR(sc, MLX_V5_IDB_HWMBOX_CMD);
2731         return(1);
2732     }
2733     return(0);
2734 }
2735
2736 /********************************************************************************
2737  * See if a command has been completed, if so acknowledge its completion
2738  * and recover the slot number and status code.
2739  */
2740 static int
2741 mlx_v5_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status)
2742 {
2743
2744     debug_called(2);
2745     MLX_IO_ASSERT_LOCKED(sc);
2746
2747     /* status available? */
2748     if (MLX_V5_GET_ODBR(sc) & MLX_V5_ODB_HWSAVAIL) {
2749         *slot = MLX_V5_GET_STATUS_IDENT(sc);            /* get command identifier */
2750         *status = MLX_V5_GET_STATUS(sc);                /* get status */
2751
2752         /* acknowledge completion */
2753         MLX_V5_PUT_ODBR(sc, MLX_V5_ODB_HWMBOX_ACK);
2754         MLX_V5_PUT_IDBR(sc, MLX_V5_IDB_SACK);
2755         return(1);
2756     }
2757     return(0);
2758 }
2759
2760 /********************************************************************************
2761  * Enable/disable interrupts as requested.
2762  */
2763 static void
2764 mlx_v5_intaction(struct mlx_softc *sc, int action)
2765 {
2766     debug_called(1);
2767     MLX_IO_ASSERT_LOCKED(sc);
2768
2769     switch(action) {
2770     case MLX_INTACTION_DISABLE:
2771         MLX_V5_PUT_IER(sc, 0xff & MLX_V5_IER_DISINT);
2772         sc->mlx_state &= ~MLX_STATE_INTEN;
2773         break;
2774     case MLX_INTACTION_ENABLE:
2775         MLX_V5_PUT_IER(sc, 0xff & ~MLX_V5_IER_DISINT);
2776         sc->mlx_state |= MLX_STATE_INTEN;
2777         break;
2778     }
2779 }
2780
2781 /********************************************************************************
2782  * Poll for firmware error codes during controller initialisation.
2783  * Returns 0 if initialisation is complete, 1 if still in progress but no
2784  * error has been fetched, 2 if an error has been retrieved.
2785  */
2786 static int
2787 mlx_v5_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2,
2788     int first)
2789 {
2790     u_int8_t    fwerror;
2791
2792     debug_called(2);
2793
2794     /* first time around, clear any hardware completion status */
2795     if (first) {
2796         MLX_V5_PUT_IDBR(sc, MLX_V5_IDB_SACK);
2797         DELAY(1000);
2798     }
2799
2800     /* init in progress? */
2801     if (MLX_V5_GET_IDBR(sc) & MLX_V5_IDB_INIT_DONE)
2802         return(0);
2803
2804     /* test for error value */
2805     fwerror = MLX_V5_GET_FWERROR(sc);
2806     if (!(fwerror & MLX_V5_FWERROR_PEND))
2807         return(1);
2808
2809     /* mask status pending bit, fetch status */
2810     *error = fwerror & ~MLX_V5_FWERROR_PEND;
2811     *param1 = MLX_V5_GET_FWERROR_PARAM1(sc);
2812     *param2 = MLX_V5_GET_FWERROR_PARAM2(sc);
2813
2814     /* acknowledge */
2815     MLX_V5_PUT_FWERROR(sc, 0xff);
2816
2817     return(2);
2818 }
2819
2820 /********************************************************************************
2821  ********************************************************************************
2822                                                                         Debugging
2823  ********************************************************************************
2824  ********************************************************************************/
2825
2826 /********************************************************************************
2827  * Return a status message describing (mc)
2828  */
2829 static char *mlx_status_messages[] = {
2830     "normal completion",                        /* 00 */
2831     "irrecoverable data error",                 /* 01 */
2832     "drive does not exist, or is offline",      /* 02 */
2833     "attempt to write beyond end of drive",     /* 03 */
2834     "bad data encountered",                     /* 04 */
2835     "invalid log entry request",                /* 05 */
2836     "attempt to rebuild online drive",          /* 06 */
2837     "new disk failed during rebuild",           /* 07 */
2838     "invalid channel/target",                   /* 08 */
2839     "rebuild/check already in progress",        /* 09 */
2840     "one or more disks are dead",               /* 10 */
2841     "invalid or non-redundant drive",           /* 11 */
2842     "channel is busy",                          /* 12 */
2843     "channel is not stopped",                   /* 13 */
2844     "rebuild successfully terminated",          /* 14 */
2845     "unsupported command",                      /* 15 */
2846     "check condition received",                 /* 16 */
2847     "device is busy",                           /* 17 */
2848     "selection or command timeout",             /* 18 */
2849     "command terminated abnormally",            /* 19 */
2850     ""
2851 };
2852
2853 static struct
2854 {
2855     int         command;
2856     u_int16_t   status;
2857     int         msg;
2858 } mlx_messages[] = {
2859     {MLX_CMD_READSG,            0x0001,  1},
2860     {MLX_CMD_READSG,            0x0002,  1},
2861     {MLX_CMD_READSG,            0x0105,  3},
2862     {MLX_CMD_READSG,            0x010c,  4},
2863     {MLX_CMD_WRITESG,           0x0001,  1},
2864     {MLX_CMD_WRITESG,           0x0002,  1},
2865     {MLX_CMD_WRITESG,           0x0105,  3},
2866     {MLX_CMD_READSG_OLD,        0x0001,  1},
2867     {MLX_CMD_READSG_OLD,        0x0002,  1},
2868     {MLX_CMD_READSG_OLD,        0x0105,  3},
2869     {MLX_CMD_WRITESG_OLD,       0x0001,  1},
2870     {MLX_CMD_WRITESG_OLD,       0x0002,  1},
2871     {MLX_CMD_WRITESG_OLD,       0x0105,  3},
2872     {MLX_CMD_LOGOP,             0x0105,  5},
2873     {MLX_CMD_REBUILDASYNC,      0x0002,  6},
2874     {MLX_CMD_REBUILDASYNC,      0x0004,  7},
2875     {MLX_CMD_REBUILDASYNC,      0x0105,  8},
2876     {MLX_CMD_REBUILDASYNC,      0x0106,  9},
2877     {MLX_CMD_REBUILDASYNC,      0x0107, 14},
2878     {MLX_CMD_CHECKASYNC,        0x0002, 10},
2879     {MLX_CMD_CHECKASYNC,        0x0105, 11},
2880     {MLX_CMD_CHECKASYNC,        0x0106,  9},
2881     {MLX_CMD_STOPCHANNEL,       0x0106, 12},
2882     {MLX_CMD_STOPCHANNEL,       0x0105,  8},
2883     {MLX_CMD_STARTCHANNEL,      0x0005, 13},
2884     {MLX_CMD_STARTCHANNEL,      0x0105,  8},
2885     {MLX_CMD_DIRECT_CDB,        0x0002, 16},
2886     {MLX_CMD_DIRECT_CDB,        0x0008, 17},
2887     {MLX_CMD_DIRECT_CDB,        0x000e, 18},
2888     {MLX_CMD_DIRECT_CDB,        0x000f, 19},
2889     {MLX_CMD_DIRECT_CDB,        0x0105,  8},
2890
2891     {0,                         0x0104, 14},
2892     {-1, 0, 0}
2893 };
2894
2895 static char *
2896 mlx_diagnose_command(struct mlx_command *mc)
2897 {
2898     static char unkmsg[80];
2899     int         i;
2900
2901     /* look up message in table */
2902     for (i = 0; mlx_messages[i].command != -1; i++)
2903         if (((mc->mc_mailbox[0] == mlx_messages[i].command) || (mlx_messages[i].command == 0)) &&
2904             (mc->mc_status == mlx_messages[i].status))
2905             return(mlx_status_messages[mlx_messages[i].msg]);
2906
2907     sprintf(unkmsg, "unknown response 0x%x for command 0x%x", (int)mc->mc_status, (int)mc->mc_mailbox[0]);
2908     return(unkmsg);
2909 }
2910
2911 /*******************************************************************************
2912  * Print a string describing the controller (sc)
2913  */
2914 static struct
2915 {
2916     int         hwid;
2917     char        *name;
2918 } mlx_controller_names[] = {
2919     {0x01,      "960P/PD"},
2920     {0x02,      "960PL"},
2921     {0x10,      "960PG"},
2922     {0x11,      "960PJ"},
2923     {0x12,      "960PR"},
2924     {0x13,      "960PT"},
2925     {0x14,      "960PTL0"},
2926     {0x15,      "960PRL"},
2927     {0x16,      "960PTL1"},
2928     {0x20,      "1164PVX"},
2929     {-1, NULL}
2930 };
2931
2932 static void
2933 mlx_describe_controller(struct mlx_softc *sc)
2934 {
2935     static char         buf[80];
2936     char                *model;
2937     int                 i;
2938
2939     for (i = 0, model = NULL; mlx_controller_names[i].name != NULL; i++) {
2940         if ((sc->mlx_enq2->me_hardware_id & 0xff) == mlx_controller_names[i].hwid) {
2941             model = mlx_controller_names[i].name;
2942             break;
2943         }
2944     }
2945     if (model == NULL) {
2946         sprintf(buf, " model 0x%x", sc->mlx_enq2->me_hardware_id & 0xff);
2947         model = buf;
2948     }
2949     device_printf(sc->mlx_dev, "DAC%s, %d channel%s, firmware %d.%02d-%c-%02d, %dMB RAM\n",
2950                   model,
2951                   sc->mlx_enq2->me_actual_channels,
2952                   sc->mlx_enq2->me_actual_channels > 1 ? "s" : "",
2953                   sc->mlx_enq2->me_firmware_id & 0xff,
2954                   (sc->mlx_enq2->me_firmware_id >> 8) & 0xff,
2955                   (sc->mlx_enq2->me_firmware_id >> 24) & 0xff,
2956                   (sc->mlx_enq2->me_firmware_id >> 16) & 0xff,
2957                   sc->mlx_enq2->me_mem_size / (1024 * 1024));
2958
2959     if (bootverbose) {
2960         device_printf(sc->mlx_dev, "  Hardware ID                 0x%08x\n", sc->mlx_enq2->me_hardware_id);
2961         device_printf(sc->mlx_dev, "  Firmware ID                 0x%08x\n", sc->mlx_enq2->me_firmware_id);
2962         device_printf(sc->mlx_dev, "  Configured/Actual channels  %d/%d\n", sc->mlx_enq2->me_configured_channels,
2963                       sc->mlx_enq2->me_actual_channels);
2964         device_printf(sc->mlx_dev, "  Max Targets                 %d\n", sc->mlx_enq2->me_max_targets);
2965         device_printf(sc->mlx_dev, "  Max Tags                    %d\n", sc->mlx_enq2->me_max_tags);
2966         device_printf(sc->mlx_dev, "  Max System Drives           %d\n", sc->mlx_enq2->me_max_sys_drives);
2967         device_printf(sc->mlx_dev, "  Max Arms                    %d\n", sc->mlx_enq2->me_max_arms);
2968         device_printf(sc->mlx_dev, "  Max Spans                   %d\n", sc->mlx_enq2->me_max_spans);
2969         device_printf(sc->mlx_dev, "  DRAM/cache/flash/NVRAM size %d/%d/%d/%d\n", sc->mlx_enq2->me_mem_size,
2970                       sc->mlx_enq2->me_cache_size, sc->mlx_enq2->me_flash_size, sc->mlx_enq2->me_nvram_size);
2971         device_printf(sc->mlx_dev, "  DRAM type                   %d\n", sc->mlx_enq2->me_mem_type);
2972         device_printf(sc->mlx_dev, "  Clock Speed                 %dns\n", sc->mlx_enq2->me_clock_speed);
2973         device_printf(sc->mlx_dev, "  Hardware Speed              %dns\n", sc->mlx_enq2->me_hardware_speed);
2974         device_printf(sc->mlx_dev, "  Max Commands                %d\n", sc->mlx_enq2->me_max_commands);
2975         device_printf(sc->mlx_dev, "  Max SG Entries              %d\n", sc->mlx_enq2->me_max_sg);
2976         device_printf(sc->mlx_dev, "  Max DP                      %d\n", sc->mlx_enq2->me_max_dp);
2977         device_printf(sc->mlx_dev, "  Max IOD                     %d\n", sc->mlx_enq2->me_max_iod);
2978         device_printf(sc->mlx_dev, "  Max Comb                    %d\n", sc->mlx_enq2->me_max_comb);
2979         device_printf(sc->mlx_dev, "  Latency                     %ds\n", sc->mlx_enq2->me_latency);
2980         device_printf(sc->mlx_dev, "  SCSI Timeout                %ds\n", sc->mlx_enq2->me_scsi_timeout);
2981         device_printf(sc->mlx_dev, "  Min Free Lines              %d\n", sc->mlx_enq2->me_min_freelines);
2982         device_printf(sc->mlx_dev, "  Rate Constant               %d\n", sc->mlx_enq2->me_rate_const);
2983         device_printf(sc->mlx_dev, "  MAXBLK                      %d\n", sc->mlx_enq2->me_maxblk);
2984         device_printf(sc->mlx_dev, "  Blocking Factor             %d sectors\n", sc->mlx_enq2->me_blocking_factor);
2985         device_printf(sc->mlx_dev, "  Cache Line Size             %d blocks\n", sc->mlx_enq2->me_cacheline);
2986         device_printf(sc->mlx_dev, "  SCSI Capability             %s%dMHz, %d bit\n",
2987                       sc->mlx_enq2->me_scsi_cap & (1<<4) ? "differential " : "",
2988                       (1 << ((sc->mlx_enq2->me_scsi_cap >> 2) & 3)) * 10,
2989                       8 << (sc->mlx_enq2->me_scsi_cap & 0x3));
2990         device_printf(sc->mlx_dev, "  Firmware Build Number       %d\n", sc->mlx_enq2->me_firmware_build);
2991         device_printf(sc->mlx_dev, "  Fault Management Type       %d\n", sc->mlx_enq2->me_fault_mgmt_type);
2992         device_printf(sc->mlx_dev, "  Features                    %b\n", sc->mlx_enq2->me_firmware_features,
2993                       "\20\4Background Init\3Read Ahead\2MORE\1Cluster\n");
2994
2995     }
2996 }
2997
2998 /*******************************************************************************
2999  * Emit a string describing the firmware handshake status code, and return a flag
3000  * indicating whether the code represents a fatal error.
3001  *
3002  * Error code interpretations are from the Linux driver, and don't directly match
3003  * the messages printed by Mylex's BIOS.  This may change if documentation on the
3004  * codes is forthcoming.
3005  */
3006 static int
3007 mlx_fw_message(struct mlx_softc *sc, int error, int param1, int param2)
3008 {
3009     switch(error) {
3010     case 0x00:
3011         device_printf(sc->mlx_dev, "physical drive %d:%d not responding\n", param2, param1);
3012         break;
3013     case 0x08:
3014         /* we could be neater about this and give some indication when we receive more of them */
3015         if (!(sc->mlx_flags & MLX_SPINUP_REPORTED)) {
3016             device_printf(sc->mlx_dev, "spinning up drives...\n");
3017             sc->mlx_flags |= MLX_SPINUP_REPORTED;
3018         }
3019         break;
3020     case 0x30:
3021         device_printf(sc->mlx_dev, "configuration checksum error\n");
3022         break;
3023     case 0x60:
3024         device_printf(sc->mlx_dev, "mirror race recovery failed\n");
3025         break;
3026     case 0x70:
3027         device_printf(sc->mlx_dev, "mirror race recovery in progress\n");
3028         break;
3029     case 0x90:
3030         device_printf(sc->mlx_dev, "physical drive %d:%d COD mismatch\n", param2, param1);
3031         break;
3032     case 0xa0:
3033         device_printf(sc->mlx_dev, "logical drive installation aborted\n");
3034         break;
3035     case 0xb0:
3036         device_printf(sc->mlx_dev, "mirror race on a critical system drive\n");
3037         break;
3038     case 0xd0:
3039         device_printf(sc->mlx_dev, "new controller configuration found\n");
3040         break;
3041     case 0xf0:
3042         device_printf(sc->mlx_dev, "FATAL MEMORY PARITY ERROR\n");
3043         return(1);
3044     default:
3045         device_printf(sc->mlx_dev, "unknown firmware initialisation error %02x:%02x:%02x\n", error, param1, param2);
3046         break;
3047     }
3048     return(0);
3049 }
3050
3051 /********************************************************************************
3052  ********************************************************************************
3053                                                                 Utility Functions
3054  ********************************************************************************
3055  ********************************************************************************/
3056
3057 /********************************************************************************
3058  * Find the disk whose unit number is (unit) on this controller
3059  */
3060 static struct mlx_sysdrive *
3061 mlx_findunit(struct mlx_softc *sc, int unit)
3062 {
3063     int         i;
3064
3065     /* search system drives */
3066     MLX_CONFIG_ASSERT_LOCKED(sc);
3067     for (i = 0; i < MLX_MAXDRIVES; i++) {
3068         /* is this one attached? */
3069         if (sc->mlx_sysdrive[i].ms_disk != 0) {
3070             /* is this the one? */
3071             if (unit == device_get_unit(sc->mlx_sysdrive[i].ms_disk))
3072                 return(&sc->mlx_sysdrive[i]);
3073         }
3074     }
3075     return(NULL);
3076 }