sys/dev/raid/aac/aac.c

   1 /*-
   2  * Copyright (c) 2000 Michael Smith
   3  * Copyright (c) 2001 Scott Long
   4  * Copyright (c) 2000 BSDi
   5  * Copyright (c) 2001 Adaptec, Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sys/dev/aac/aac.c,v 1.170 2012/02/13 16:48:49 emaste Exp $
  30  */
  31
  32 /*
  33  * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters.
  34  */
  35 #define AAC_DRIVERNAME                  "aac"
  36
  37 #include "opt_aac.h"
  38
  39 /* #include <stddef.h> */
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/malloc.h>
  43 #include <sys/kernel.h>
  44 #include <sys/kthread.h>
  45 #include <sys/poll.h>
  46
  47 #include <sys/bus.h>
  48 #include <sys/conf.h>
  49 #include <sys/signalvar.h>
  50 #include <sys/time.h>
  51 #include <sys/eventhandler.h>
  52 #include <sys/rman.h>
  53
  54 #include <sys/bus_dma.h>
  55 #include <sys/device.h>
  56 #include <sys/mplock2.h>
  57
  58 #include <bus/pci/pcireg.h>
  59 #include <bus/pci/pcivar.h>
  60
  61 #include <dev/raid/aac/aacreg.h>
  62 #include <dev/raid/aac/aac_ioctl.h>
  63 #include <dev/raid/aac/aacvar.h>
  64 #include <dev/raid/aac/aac_tables.h>
  65
  66 static void     aac_startup(void *arg);
  67 static void     aac_add_container(struct aac_softc *sc,
  68                                   struct aac_mntinforesp *mir, int f);
  69 static void     aac_get_bus_info(struct aac_softc *sc);
  70 static void     aac_daemon(void *arg);
  71
  72 /* Command Processing */
  73 static void     aac_timeout(struct aac_softc *sc);
  74 static void     aac_complete(void *context, int pending);
  75 static int      aac_bio_command(struct aac_softc *sc, struct aac_command **cmp);
  76 static void     aac_bio_complete(struct aac_command *cm);
  77 static int      aac_wait_command(struct aac_command *cm);
  78 static void     aac_command_thread(void *arg);
  79
  80 /* Command Buffer Management */
  81 static void     aac_map_command_sg(void *arg, bus_dma_segment_t *segs,
  82                                    int nseg, int error);
  83 static void     aac_map_command_helper(void *arg, bus_dma_segment_t *segs,
  84                                        int nseg, int error);
  85 static int      aac_alloc_commands(struct aac_softc *sc);
  86 static void     aac_free_commands(struct aac_softc *sc);
  87 static void     aac_unmap_command(struct aac_command *cm);
  88
  89 /* Hardware Interface */
  90 static int      aac_alloc(struct aac_softc *sc);
  91 static void     aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg,
  92                                int error);
  93 static int      aac_check_firmware(struct aac_softc *sc);
  94 static int      aac_init(struct aac_softc *sc);
  95 static int      aac_sync_command(struct aac_softc *sc, u_int32_t command,
  96                                  u_int32_t arg0, u_int32_t arg1, u_int32_t arg2,
  97                                  u_int32_t arg3, u_int32_t *sp);
  98 static int      aac_setup_intr(struct aac_softc *sc);
  99 static int      aac_enqueue_fib(struct aac_softc *sc, int queue,
 100                                 struct aac_command *cm);
 101 static int      aac_dequeue_fib(struct aac_softc *sc, int queue,
 102                                 u_int32_t *fib_size, struct aac_fib **fib_addr);
 103 static int      aac_enqueue_response(struct aac_softc *sc, int queue,
 104                                      struct aac_fib *fib);
 105
 106 /* StrongARM interface */
 107 static int      aac_sa_get_fwstatus(struct aac_softc *sc);
 108 static void     aac_sa_qnotify(struct aac_softc *sc, int qbit);
 109 static int      aac_sa_get_istatus(struct aac_softc *sc);
 110 static void     aac_sa_clear_istatus(struct aac_softc *sc, int mask);
 111 static void     aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
 112                                    u_int32_t arg0, u_int32_t arg1,
 113                                    u_int32_t arg2, u_int32_t arg3);
 114 static int      aac_sa_get_mailbox(struct aac_softc *sc, int mb);
 115 static void     aac_sa_set_interrupts(struct aac_softc *sc, int enable);
 116
 117 struct aac_interface aac_sa_interface = {
 118         aac_sa_get_fwstatus,
 119         aac_sa_qnotify,
 120         aac_sa_get_istatus,
 121         aac_sa_clear_istatus,
 122         aac_sa_set_mailbox,
 123         aac_sa_get_mailbox,
 124         aac_sa_set_interrupts,
 125         NULL, NULL, NULL
 126 };
 127
 128 /* i960Rx interface */
 129 static int      aac_rx_get_fwstatus(struct aac_softc *sc);
 130 static void     aac_rx_qnotify(struct aac_softc *sc, int qbit);
 131 static int      aac_rx_get_istatus(struct aac_softc *sc);
 132 static void     aac_rx_clear_istatus(struct aac_softc *sc, int mask);
 133 static void     aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
 134                                    u_int32_t arg0, u_int32_t arg1,
 135                                    u_int32_t arg2, u_int32_t arg3);
 136 static int      aac_rx_get_mailbox(struct aac_softc *sc, int mb);
 137 static void     aac_rx_set_interrupts(struct aac_softc *sc, int enable);
 138 static int aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm);
 139 static int aac_rx_get_outb_queue(struct aac_softc *sc);
 140 static void aac_rx_set_outb_queue(struct aac_softc *sc, int index);
 141
 142 struct aac_interface aac_rx_interface = {
 143         aac_rx_get_fwstatus,
 144         aac_rx_qnotify,
 145         aac_rx_get_istatus,
 146         aac_rx_clear_istatus,
 147         aac_rx_set_mailbox,
 148         aac_rx_get_mailbox,
 149         aac_rx_set_interrupts,
 150         aac_rx_send_command,
 151         aac_rx_get_outb_queue,
 152         aac_rx_set_outb_queue
 153 };
 154
 155 /* Rocket/MIPS interface */
 156 static int      aac_rkt_get_fwstatus(struct aac_softc *sc);
 157 static void     aac_rkt_qnotify(struct aac_softc *sc, int qbit);
 158 static int      aac_rkt_get_istatus(struct aac_softc *sc);
 159 static void     aac_rkt_clear_istatus(struct aac_softc *sc, int mask);
 160 static void     aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command,
 161                                     u_int32_t arg0, u_int32_t arg1,
 162                                     u_int32_t arg2, u_int32_t arg3);
 163 static int      aac_rkt_get_mailbox(struct aac_softc *sc, int mb);
 164 static void     aac_rkt_set_interrupts(struct aac_softc *sc, int enable);
 165 static int aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm);
 166 static int aac_rkt_get_outb_queue(struct aac_softc *sc);
 167 static void aac_rkt_set_outb_queue(struct aac_softc *sc, int index);
 168
 169 struct aac_interface aac_rkt_interface = {
 170         aac_rkt_get_fwstatus,
 171         aac_rkt_qnotify,
 172         aac_rkt_get_istatus,
 173         aac_rkt_clear_istatus,
 174         aac_rkt_set_mailbox,
 175         aac_rkt_get_mailbox,
 176         aac_rkt_set_interrupts,
 177         aac_rkt_send_command,
 178         aac_rkt_get_outb_queue,
 179         aac_rkt_set_outb_queue
 180 };
 181
 182 /* Debugging and Diagnostics */
 183 static void     aac_describe_controller(struct aac_softc *sc);
 184 static char     *aac_describe_code(struct aac_code_lookup *table,
 185                                    u_int32_t code);
 186
 187 /* Management Interface */
 188 static d_open_t         aac_open;
 189 static d_close_t        aac_close;
 190 static d_ioctl_t        aac_ioctl;
 191 static d_kqfilter_t     aac_kqfilter;
 192 static void             aac_filter_detach(struct knote *kn);
 193 static int              aac_filter_read(struct knote *kn, long hint);
 194 static int              aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib);
 195 static int              aac_ioctl_send_raw_srb(struct aac_softc *sc, caddr_t arg);
 196 static void             aac_handle_aif(struct aac_softc *sc,
 197                                            struct aac_fib *fib);
 198 static int              aac_rev_check(struct aac_softc *sc, caddr_t udata);
 199 static int              aac_open_aif(struct aac_softc *sc, caddr_t arg);
 200 static int              aac_close_aif(struct aac_softc *sc, caddr_t arg);
 201 static int              aac_getnext_aif(struct aac_softc *sc, caddr_t arg);
 202 static int              aac_return_aif(struct aac_softc *sc,
 203                                         struct aac_fib_context *ctx, caddr_t uptr);
 204 static int              aac_query_disk(struct aac_softc *sc, caddr_t uptr);
 205 static int              aac_get_pci_info(struct aac_softc *sc, caddr_t uptr);
 206 static int              aac_supported_features(struct aac_softc *sc, caddr_t uptr);
 207 static void             aac_ioctl_event(struct aac_softc *sc,
 208                                         struct aac_event *event, void *arg);
 209 static struct aac_mntinforesp *
 210         aac_get_container_info(struct aac_softc *sc, struct aac_fib *fib, int cid);
 211
 212 static struct dev_ops aac_ops = {
 213         { "aac", 0, 0 },
 214         .d_open =       aac_open,
 215         .d_close =      aac_close,
 216         .d_ioctl =      aac_ioctl,
 217         .d_kqfilter =   aac_kqfilter
 218 };
 219
 220 static MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver");
 221
 222 /* sysctl node */
 223 static SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters");
 224
 225 /*
 226  * Device Interface
 227  */
 228
 229 /*
 230  * Initialize the controller and softc
 231  */
 232 int
 233 aac_attach(struct aac_softc *sc)
 234 {
 235         int error, unit;
 236
 237         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 238
 239         /*
 240          * Initialize per-controller queues.
 241          */
 242         aac_initq_free(sc);
 243         aac_initq_ready(sc);
 244         aac_initq_busy(sc);
 245         aac_initq_bio(sc);
 246
 247         /*
 248          * Initialize command-completion task.
 249          */
 250         TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc);
 251
 252         /* mark controller as suspended until we get ourselves organised */
 253         sc->aac_state |= AAC_STATE_SUSPEND;
 254
 255         /*
 256          * Check that the firmware on the card is supported.
 257          */
 258         if ((error = aac_check_firmware(sc)) != 0)
 259                 return(error);
 260
 261         /*
 262          * Initialize locks
 263          */
 264         lockinit(&sc->aac_aifq_lock, "AAC AIF lock", 0, LK_CANRECURSE);
 265         lockinit(&sc->aac_io_lock, "AAC I/O lock", 0, LK_CANRECURSE);
 266         lockinit(&sc->aac_container_lock, "AAC container lock", 0, LK_CANRECURSE);
 267         TAILQ_INIT(&sc->aac_container_tqh);
 268         TAILQ_INIT(&sc->aac_ev_cmfree);
 269
 270         /* Initialize the clock daemon callout. */
 271         callout_init(&sc->aac_daemontime);
 272
 273         /*
 274          * Initialize the adapter.
 275          */
 276         if ((error = aac_alloc(sc)) != 0)
 277                 return(error);
 278         if ((error = aac_init(sc)) != 0)
 279                 return(error);
 280
 281         /*
 282          * Allocate and connect our interrupt.
 283          */
 284         if ((error = aac_setup_intr(sc)) != 0)
 285                 return(error);
 286
 287         /*
 288          * Print a little information about the controller.
 289          */
 290         aac_describe_controller(sc);
 291
 292         /*
 293          * Add sysctls.
 294          */
 295         sysctl_ctx_init(&sc->aac_sysctl_ctx);
 296         sc->aac_sysctl_tree = SYSCTL_ADD_NODE(&sc->aac_sysctl_ctx,
 297             SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
 298             device_get_nameunit(sc->aac_dev), CTLFLAG_RD, 0, "");
 299         if (sc->aac_sysctl_tree == NULL) {
 300                 device_printf(sc->aac_dev, "can't add sysctl node\n");
 301                 return (EINVAL);
 302         }
 303         SYSCTL_ADD_INT(&sc->aac_sysctl_ctx,
 304             SYSCTL_CHILDREN(sc->aac_sysctl_tree),
 305             OID_AUTO, "firmware_build", CTLFLAG_RD,
 306             &sc->aac_revision.buildNumber, 0,
 307             "firmware build number");
 308
 309         /*
 310          * Register to probe our containers later.
 311          */
 312         sc->aac_ich.ich_func = aac_startup;
 313         sc->aac_ich.ich_arg = sc;
 314         sc->aac_ich.ich_desc = "aac";
 315         if (config_intrhook_establish(&sc->aac_ich) != 0) {
 316                 device_printf(sc->aac_dev,
 317                               "can't establish configuration hook\n");
 318                 return(ENXIO);
 319         }
 320
 321         /*
 322          * Make the control device.
 323          */
 324         unit = device_get_unit(sc->aac_dev);
 325         sc->aac_dev_t = make_dev(&aac_ops, unit, UID_ROOT, GID_OPERATOR,
 326                                  0640, "aac%d", unit);
 327         (void)make_dev_alias(sc->aac_dev_t, "afa%d", unit);
 328         (void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit);
 329         sc->aac_dev_t->si_drv1 = sc;
 330
 331         /* Create the AIF thread */
 332         if (kthread_create(aac_command_thread, sc,
 333                            &sc->aifthread, "aac%daif", unit))
 334                 panic("Could not create AIF thread");
 335
 336         /* Register the shutdown method to only be called post-dump */
 337         if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown,
 338             sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL)
 339                 device_printf(sc->aac_dev,
 340                               "shutdown event registration failed\n");
 341
 342         /* Register with CAM for the non-DASD devices */
 343         if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) {
 344                 TAILQ_INIT(&sc->aac_sim_tqh);
 345                 aac_get_bus_info(sc);
 346         }
 347
 348         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
 349         callout_reset(&sc->aac_daemontime, 60 * hz, aac_daemon, sc);
 350         lockmgr(&sc->aac_io_lock, LK_RELEASE);
 351
 352         return(0);
 353 }
 354
 355 static void
 356 aac_daemon(void *arg)
 357 {
 358         struct timeval tv;
 359         struct aac_softc *sc;
 360         struct aac_fib *fib;
 361
 362         sc = arg;
 363         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
 364
 365         if (callout_pending(&sc->aac_daemontime) ||
 366             callout_active(&sc->aac_daemontime) == 0)
 367                 return;
 368         getmicrotime(&tv);
 369         aac_alloc_sync_fib(sc, &fib);
 370         *(uint32_t *)fib->data = tv.tv_sec;
 371         aac_sync_fib(sc, SendHostTime, 0, fib, sizeof(uint32_t));
 372         aac_release_sync_fib(sc);
 373         lockmgr(&sc->aac_io_lock, LK_RELEASE);
 374         callout_reset(&sc->aac_daemontime, 30 * 60 * hz, aac_daemon, sc);
 375 }
 376
 377 void
 378 aac_add_event(struct aac_softc *sc, struct aac_event *event)
 379 {
 380
 381         switch (event->ev_type & AAC_EVENT_MASK) {
 382         case AAC_EVENT_CMFREE:
 383                 TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links);
 384                 break;
 385         default:
 386                 device_printf(sc->aac_dev, "aac_add event: unknown event %d\n",
 387                     event->ev_type);
 388                 break;
 389         }
 390
 391         return;
 392 }
 393
 394 /*
 395  * Request information of container #cid
 396  */
 397 static struct aac_mntinforesp *
 398 aac_get_container_info(struct aac_softc *sc, struct aac_fib *fib, int cid)
 399 {
 400         struct aac_mntinfo *mi;
 401
 402         mi = (struct aac_mntinfo *)&fib->data[0];
 403         /* use 64-bit LBA if enabled */
 404         mi->Command = (sc->flags & AAC_FLAGS_LBA_64BIT) ?
 405             VM_NameServe64 : VM_NameServe;
 406         mi->MntType = FT_FILESYS;
 407         mi->MntCount = cid;
 408
 409         if (aac_sync_fib(sc, ContainerCommand, 0, fib,
 410                          sizeof(struct aac_mntinfo))) {
 411                 device_printf(sc->aac_dev, "Error probing container %d\n", cid);
 412                 return (NULL);
 413         }
 414
 415         return ((struct aac_mntinforesp *)&fib->data[0]);
 416 }
 417
 418 /*
 419  * Probe for containers, create disks.
 420  */
 421 static void
 422 aac_startup(void *arg)
 423 {
 424         struct aac_softc *sc;
 425         struct aac_fib *fib;
 426         struct aac_mntinforesp *mir;
 427         int count = 0, i = 0;
 428
 429         sc = (struct aac_softc *)arg;
 430         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 431
 432         /* disconnect ourselves from the intrhook chain */
 433         config_intrhook_disestablish(&sc->aac_ich);
 434
 435         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
 436         aac_alloc_sync_fib(sc, &fib);
 437
 438         /* loop over possible containers */
 439         do {
 440                 if ((mir = aac_get_container_info(sc, fib, i)) == NULL)
 441                         continue;
 442                 if (i == 0)
 443                         count = mir->MntRespCount;
 444                 aac_add_container(sc, mir, 0);
 445                 i++;
 446         } while ((i < count) && (i < AAC_MAX_CONTAINERS));
 447
 448         aac_release_sync_fib(sc);
 449         lockmgr(&sc->aac_io_lock, LK_RELEASE);
 450
 451         /* poke the bus to actually attach the child devices */
 452         if (bus_generic_attach(sc->aac_dev))
 453                 device_printf(sc->aac_dev, "bus_generic_attach failed\n");
 454
 455         /* mark the controller up */
 456         sc->aac_state &= ~AAC_STATE_SUSPEND;
 457
 458         /* enable interrupts now */
 459         AAC_UNMASK_INTERRUPTS(sc);
 460 }
 461
 462 /*
 463  * Create a device to represent a new container
 464  */
 465 static void
 466 aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f)
 467 {
 468         struct aac_container *co;
 469         device_t child;
 470
 471         /*
 472          * Check container volume type for validity.  Note that many of
 473          * the possible types may never show up.
 474          */
 475         if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) {
 476                 co = (struct aac_container *)kmalloc(sizeof *co, M_AACBUF,
 477                        M_INTWAIT | M_ZERO);
 478                 fwprintf(sc, HBA_FLAGS_DBG_INIT_B, "id %x  name '%.16s'  size %u  type %d",
 479                       mir->MntTable[0].ObjectId,
 480                       mir->MntTable[0].FileSystemName,
 481                       mir->MntTable[0].Capacity, mir->MntTable[0].VolType);
 482
 483                 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL)
 484                         device_printf(sc->aac_dev, "device_add_child failed\n");
 485                 else
 486                         device_set_ivars(child, co);
 487                 device_set_desc(child, aac_describe_code(aac_container_types,
 488                                 mir->MntTable[0].VolType));
 489                 co->co_disk = child;
 490                 co->co_found = f;
 491                 bcopy(&mir->MntTable[0], &co->co_mntobj,
 492                       sizeof(struct aac_mntobj));
 493                 lockmgr(&sc->aac_container_lock, LK_EXCLUSIVE);
 494                 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link);
 495                 lockmgr(&sc->aac_container_lock, LK_RELEASE);
 496         }
 497 }
 498
 499 /*
 500  * Allocate resources associated with (sc)
 501  */
 502 static int
 503 aac_alloc(struct aac_softc *sc)
 504 {
 505
 506         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 507
 508         /*
 509          * Create DMA tag for mapping buffers into controller-addressable space.
 510          */
 511         if (bus_dma_tag_create(sc->aac_parent_dmat,     /* parent */
 512                                1, 0,                    /* algnmnt, boundary */
 513                                (sc->flags & AAC_FLAGS_SG_64BIT) ?
 514                                BUS_SPACE_MAXADDR :
 515                                BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
 516                                BUS_SPACE_MAXADDR,       /* highaddr */
 517                                NULL, NULL,              /* filter, filterarg */
 518                                MAXBSIZE,                /* maxsize */
 519                                sc->aac_sg_tablesize,    /* nsegments */
 520                                MAXBSIZE,                /* maxsegsize */
 521                                BUS_DMA_ALLOCNOW,        /* flags */
 522                                &sc->aac_buffer_dmat)) {
 523                 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n");
 524                 return (ENOMEM);
 525         }
 526
 527         /*
 528          * Create DMA tag for mapping FIBs into controller-addressable space..
 529          */
 530         if (bus_dma_tag_create(sc->aac_parent_dmat,     /* parent */
 531                                1, 0,                    /* algnmnt, boundary */
 532                                (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
 533                                BUS_SPACE_MAXADDR_32BIT :
 534                                0x7fffffff,              /* lowaddr */
 535                                BUS_SPACE_MAXADDR,       /* highaddr */
 536                                NULL, NULL,              /* filter, filterarg */
 537                                sc->aac_max_fibs_alloc *
 538                                sc->aac_max_fib_size,  /* maxsize */
 539                                1,                       /* nsegments */
 540                                sc->aac_max_fibs_alloc *
 541                                sc->aac_max_fib_size,    /* maxsize */
 542                                0,                       /* flags */
 543                                &sc->aac_fib_dmat)) {
 544                 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");
 545                 return (ENOMEM);
 546         }
 547
 548         /*
 549          * Create DMA tag for the common structure and allocate it.
 550          */
 551         if (bus_dma_tag_create(sc->aac_parent_dmat,     /* parent */
 552                                1, 0,                    /* algnmnt, boundary */
 553                                (sc->flags & AAC_FLAGS_4GB_WINDOW) ?
 554                                BUS_SPACE_MAXADDR_32BIT :
 555                                0x7fffffff,              /* lowaddr */
 556                                BUS_SPACE_MAXADDR,       /* highaddr */
 557                                NULL, NULL,              /* filter, filterarg */
 558                                8192 + sizeof(struct aac_common), /* maxsize */
 559                                1,                       /* nsegments */
 560                                BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
 561                                0,                       /* flags */
 562                                &sc->aac_common_dmat)) {
 563                 device_printf(sc->aac_dev,
 564                               "can't allocate common structure DMA tag\n");
 565                 return (ENOMEM);
 566         }
 567         if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common,
 568                              BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) {
 569                 device_printf(sc->aac_dev, "can't allocate common structure\n");
 570                 return (ENOMEM);
 571         }
 572
 573         /*
 574          * Work around a bug in the 2120 and 2200 that cannot DMA commands
 575          * below address 8192 in physical memory.
 576          * XXX If the padding is not needed, can it be put to use instead
 577          * of ignored?
 578          */
 579         (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap,
 580                         sc->aac_common, 8192 + sizeof(*sc->aac_common),
 581                         aac_common_map, sc, 0);
 582
 583         if (sc->aac_common_busaddr < 8192) {
 584                 sc->aac_common = (struct aac_common *)
 585                     ((uint8_t *)sc->aac_common + 8192);
 586                 sc->aac_common_busaddr += 8192;
 587         }
 588         bzero(sc->aac_common, sizeof(*sc->aac_common));
 589
 590         /* Allocate some FIBs and associated command structs */
 591         TAILQ_INIT(&sc->aac_fibmap_tqh);
 592         sc->aac_commands = kmalloc(sc->aac_max_fibs * sizeof(struct aac_command),
 593                                   M_AACBUF, M_WAITOK|M_ZERO);
 594         while (sc->total_fibs < sc->aac_max_fibs) {
 595                 if (aac_alloc_commands(sc) != 0)
 596                         break;
 597         }
 598         if (sc->total_fibs == 0)
 599                 return (ENOMEM);
 600
 601         return (0);
 602 }
 603
 604 /*
 605  * Free all of the resources associated with (sc)
 606  *
 607  * Should not be called if the controller is active.
 608  */
 609 void
 610 aac_free(struct aac_softc *sc)
 611 {
 612
 613         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 614
 615         /* remove the control device */
 616         if (sc->aac_dev_t != NULL)
 617                 destroy_dev(sc->aac_dev_t);
 618
 619         /* throw away any FIB buffers, discard the FIB DMA tag */
 620         aac_free_commands(sc);
 621         if (sc->aac_fib_dmat)
 622                 bus_dma_tag_destroy(sc->aac_fib_dmat);
 623
 624         kfree(sc->aac_commands, M_AACBUF);
 625
 626         /* destroy the common area */
 627         if (sc->aac_common) {
 628                 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap);
 629                 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common,
 630                                 sc->aac_common_dmamap);
 631         }
 632         if (sc->aac_common_dmat)
 633                 bus_dma_tag_destroy(sc->aac_common_dmat);
 634
 635         /* disconnect the interrupt handler */
 636         if (sc->aac_intr)
 637                 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr);
 638         if (sc->aac_irq != NULL)
 639                 bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid,
 640                                      sc->aac_irq);
 641
 642         /* destroy data-transfer DMA tag */
 643         if (sc->aac_buffer_dmat)
 644                 bus_dma_tag_destroy(sc->aac_buffer_dmat);
 645
 646         /* destroy the parent DMA tag */
 647         if (sc->aac_parent_dmat)
 648                 bus_dma_tag_destroy(sc->aac_parent_dmat);
 649
 650         /* release the register window mapping */
 651         if (sc->aac_regs_res0 != NULL)
 652                 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
 653                                      sc->aac_regs_rid0, sc->aac_regs_res0);
 654         if (sc->aac_hwif == AAC_HWIF_NARK && sc->aac_regs_res1 != NULL)
 655                 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY,
 656                                      sc->aac_regs_rid1, sc->aac_regs_res1);
 657         dev_ops_remove_minor(&aac_ops, device_get_unit(sc->aac_dev));
 658
 659         sysctl_ctx_free(&sc->aac_sysctl_ctx);
 660 }
 661
 662 /*
 663  * Disconnect from the controller completely, in preparation for unload.
 664  */
 665 int
 666 aac_detach(device_t dev)
 667 {
 668         struct aac_softc *sc;
 669         struct aac_container *co;
 670         struct aac_sim  *sim;
 671         int error;
 672
 673         sc = device_get_softc(dev);
 674         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 675
 676 #if 0 /* XXX swildner */
 677         callout_drain(&sc->aac_daemontime);
 678 #else
 679         callout_stop(&sc->aac_daemontime);
 680 #endif
 681
 682         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
 683         while (sc->aifflags & AAC_AIFFLAGS_RUNNING) {
 684                 sc->aifflags |= AAC_AIFFLAGS_EXIT;
 685                 wakeup(sc->aifthread);
 686                 lksleep(sc->aac_dev, &sc->aac_io_lock, 0, "aacdch", 0);
 687         }
 688         lockmgr(&sc->aac_io_lock, LK_RELEASE);
 689         KASSERT((sc->aifflags & AAC_AIFFLAGS_RUNNING) == 0,
 690             ("%s: invalid detach state", __func__));
 691
 692         /* Remove the child containers */
 693         while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) {
 694                 error = device_delete_child(dev, co->co_disk);
 695                 if (error)
 696                         return (error);
 697                 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link);
 698                 kfree(co, M_AACBUF);
 699         }
 700
 701         /* Remove the CAM SIMs */
 702         while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) {
 703                 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link);
 704                 error = device_delete_child(dev, sim->sim_dev);
 705                 if (error)
 706                         return (error);
 707                 kfree(sim, M_AACBUF);
 708         }
 709
 710         if ((error = aac_shutdown(dev)))
 711                 return(error);
 712
 713         EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh);
 714
 715         aac_free(sc);
 716
 717         lockuninit(&sc->aac_aifq_lock);
 718         lockuninit(&sc->aac_io_lock);
 719         lockuninit(&sc->aac_container_lock);
 720
 721         return(0);
 722 }
 723
 724 /*
 725  * Bring the controller down to a dormant state and detach all child devices.
 726  *
 727  * This function is called before detach or system shutdown.
 728  *
 729  * Note that we can assume that the bioq on the controller is empty, as we won't
 730  * allow shutdown if any device is open.
 731  */
 732 int
 733 aac_shutdown(device_t dev)
 734 {
 735         struct aac_softc *sc;
 736         struct aac_fib *fib;
 737         struct aac_close_command *cc;
 738
 739         sc = device_get_softc(dev);
 740         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 741
 742         sc->aac_state |= AAC_STATE_SUSPEND;
 743
 744         /*
 745          * Send a Container shutdown followed by a HostShutdown FIB to the
 746          * controller to convince it that we don't want to talk to it anymore.
 747          * We've been closed and all I/O completed already
 748          */
 749         device_printf(sc->aac_dev, "shutting down controller...");
 750
 751         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
 752         aac_alloc_sync_fib(sc, &fib);
 753         cc = (struct aac_close_command *)&fib->data[0];
 754
 755         bzero(cc, sizeof(struct aac_close_command));
 756         cc->Command = VM_CloseAll;
 757         cc->ContainerId = 0xffffffff;
 758         if (aac_sync_fib(sc, ContainerCommand, 0, fib,
 759             sizeof(struct aac_close_command)))
 760                 kprintf("FAILED.\n");
 761         else
 762                 kprintf("done\n");
 763 #if 0
 764         else {
 765                 fib->data[0] = 0;
 766                 /*
 767                  * XXX Issuing this command to the controller makes it shut down
 768                  * but also keeps it from coming back up without a reset of the
 769                  * PCI bus.  This is not desirable if you are just unloading the
 770                  * driver module with the intent to reload it later.
 771                  */
 772                 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN,
 773                     fib, 1)) {
 774                         kprintf("FAILED.\n");
 775                 } else {
 776                         kprintf("done.\n");
 777                 }
 778         }
 779 #endif
 780
 781         AAC_MASK_INTERRUPTS(sc);
 782         aac_release_sync_fib(sc);
 783         lockmgr(&sc->aac_io_lock, LK_RELEASE);
 784
 785         return(0);
 786 }
 787
 788 /*
 789  * Bring the controller to a quiescent state, ready for system suspend.
 790  */
 791 int
 792 aac_suspend(device_t dev)
 793 {
 794         struct aac_softc *sc;
 795
 796         sc = device_get_softc(dev);
 797
 798         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 799         sc->aac_state |= AAC_STATE_SUSPEND;
 800
 801         AAC_MASK_INTERRUPTS(sc);
 802         return(0);
 803 }
 804
 805 /*
 806  * Bring the controller back to a state ready for operation.
 807  */
 808 int
 809 aac_resume(device_t dev)
 810 {
 811         struct aac_softc *sc;
 812
 813         sc = device_get_softc(dev);
 814
 815         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 816         sc->aac_state &= ~AAC_STATE_SUSPEND;
 817         AAC_UNMASK_INTERRUPTS(sc);
 818         return(0);
 819 }
 820
 821 /*
 822  * Interrupt handler for NEW_COMM interface.
 823  */
 824 void
 825 aac_new_intr(void *arg)
 826 {
 827         struct aac_softc *sc;
 828         u_int32_t index, fast;
 829         struct aac_command *cm;
 830         struct aac_fib *fib;
 831         int i;
 832
 833         sc = (struct aac_softc *)arg;
 834
 835         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 836         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
 837         while (1) {
 838                 index = AAC_GET_OUTB_QUEUE(sc);
 839                 if (index == 0xffffffff)
 840                         index = AAC_GET_OUTB_QUEUE(sc);
 841                 if (index == 0xffffffff)
 842                         break;
 843                 if (index & 2) {
 844                         if (index == 0xfffffffe) {
 845                                 /* XXX This means that the controller wants
 846                                  * more work.  Ignore it for now.
 847                                  */
 848                                 continue;
 849                         }
 850                         /* AIF */
 851                         fib = (struct aac_fib *)kmalloc(sizeof *fib, M_AACBUF,
 852                                    M_INTWAIT | M_ZERO);
 853                         index &= ~2;
 854                         for (i = 0; i < sizeof(struct aac_fib)/4; ++i)
 855                                 ((u_int32_t *)fib)[i] = AAC_MEM1_GETREG4(sc, index + i*4);
 856                         aac_handle_aif(sc, fib);
 857                         kfree(fib, M_AACBUF);
 858
 859                         /*
 860                          * AIF memory is owned by the adapter, so let it
 861                          * know that we are done with it.
 862                          */
 863                         AAC_SET_OUTB_QUEUE(sc, index);
 864                         AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY);
 865                 } else {
 866                         fast = index & 1;
 867                         cm = sc->aac_commands + (index >> 2);
 868                         fib = cm->cm_fib;
 869                         if (fast) {
 870                                 fib->Header.XferState |= AAC_FIBSTATE_DONEADAP;
 871                                 *((u_int32_t *)(fib->data)) = AAC_ERROR_NORMAL;
 872                         }
 873                         aac_remove_busy(cm);
 874                         aac_unmap_command(cm);
 875                         cm->cm_flags |= AAC_CMD_COMPLETED;
 876
 877                         /* is there a completion handler? */
 878                         if (cm->cm_complete != NULL) {
 879                                 cm->cm_complete(cm);
 880                         } else {
 881                                 /* assume that someone is sleeping on this
 882                                  * command
 883                                  */
 884                                 wakeup(cm);
 885                         }
 886                         sc->flags &= ~AAC_QUEUE_FRZN;
 887                 }
 888         }
 889         /* see if we can start some more I/O */
 890         if ((sc->flags & AAC_QUEUE_FRZN) == 0)
 891                 aac_startio(sc);
 892
 893         lockmgr(&sc->aac_io_lock, LK_RELEASE);
 894 }
 895
 896 /*
 897  * Interrupt filter for !NEW_COMM interface.
 898  */
 899 void
 900 aac_filter(void *arg)
 901 {
 902         struct aac_softc *sc;
 903         u_int16_t reason;
 904
 905         sc = (struct aac_softc *)arg;
 906
 907         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 908         /*
 909          * Read the status register directly.  This is faster than taking the
 910          * driver lock and reading the queues directly.  It also saves having
 911          * to turn parts of the driver lock into a spin mutex, which would be
 912          * ugly.
 913          */
 914         reason = AAC_GET_ISTATUS(sc);
 915         AAC_CLEAR_ISTATUS(sc, reason);
 916
 917         /* handle completion processing */
 918         if (reason & AAC_DB_RESPONSE_READY)
 919                 taskqueue_enqueue(taskqueue_swi, &sc->aac_task_complete);
 920
 921         /* controller wants to talk to us */
 922         if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) {
 923                 /*
 924                  * XXX Make sure that we don't get fooled by strange messages
 925                  * that start with a NULL.
 926                  */
 927                 if ((reason & AAC_DB_PRINTF) &&
 928                         (sc->aac_common->ac_printf[0] == 0))
 929                         sc->aac_common->ac_printf[0] = 32;
 930
 931                 /*
 932                  * This might miss doing the actual wakeup.  However, the
 933                  * lksleep that this is waking up has a timeout, so it will
 934                  * wake up eventually.  AIFs and printfs are low enough
 935                  * priority that they can handle hanging out for a few seconds
 936                  * if needed.
 937                  */
 938                 wakeup(sc->aifthread);
 939         }
 940 }
 941
 942 /*
 943  * Command Processing
 944  */
 945
 946 /*
 947  * Start as much queued I/O as possible on the controller
 948  */
 949 void
 950 aac_startio(struct aac_softc *sc)
 951 {
 952         struct aac_command *cm;
 953         int error;
 954
 955         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
 956
 957         for (;;) {
 958                 /*
 959                  * This flag might be set if the card is out of resources.
 960                  * Checking it here prevents an infinite loop of deferrals.
 961                  */
 962                 if (sc->flags & AAC_QUEUE_FRZN)
 963                         break;
 964
 965                 /*
 966                  * Try to get a command that's been put off for lack of
 967                  * resources
 968                  */
 969                 cm = aac_dequeue_ready(sc);
 970
 971                 /*
 972                  * Try to build a command off the bio queue (ignore error
 973                  * return)
 974                  */
 975                 if (cm == NULL)
 976                         aac_bio_command(sc, &cm);
 977
 978                 /* nothing to do? */
 979                 if (cm == NULL)
 980                         break;
 981
 982                 /* don't map more than once */
 983                 if (cm->cm_flags & AAC_CMD_MAPPED)
 984                         panic("aac: command %p already mapped", cm);
 985
 986                 /*
 987                  * Set up the command to go to the controller.  If there are no
 988                  * data buffers associated with the command then it can bypass
 989                  * busdma.
 990                  */
 991                 if (cm->cm_datalen != 0) {
 992                         error = bus_dmamap_load(sc->aac_buffer_dmat,
 993                                                 cm->cm_datamap, cm->cm_data,
 994                                                 cm->cm_datalen,
 995                                                 aac_map_command_sg, cm, 0);
 996                         if (error == EINPROGRESS) {
 997                                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "freezing queue\n");
 998                                 sc->flags |= AAC_QUEUE_FRZN;
 999                                 error = 0;
1000                         } else if (error != 0)
1001                                 panic("aac_startio: unexpected error %d from "
1002                                       "busdma", error);
1003                 } else
1004                         aac_map_command_sg(cm, NULL, 0, 0);
1005         }
1006 }
1007
1008 /*
1009  * Handle notification of one or more FIBs coming from the controller.
1010  */
1011 static void
1012 aac_command_thread(void *arg)
1013 {
1014         struct aac_softc *sc = arg;
1015         struct aac_fib *fib;
1016         u_int32_t fib_size;
1017         int size, retval;
1018
1019         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1020
1021         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1022         sc->aifflags = AAC_AIFFLAGS_RUNNING;
1023
1024         while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) {
1025
1026                 retval = 0;
1027                 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0)
1028                         retval = lksleep(sc->aifthread, &sc->aac_io_lock, 0,
1029                                         "aifthd", AAC_PERIODIC_INTERVAL * hz);
1030
1031                 /*
1032                  * First see if any FIBs need to be allocated.  This needs
1033                  * to be called without the driver lock because contigmalloc
1034                  * can sleep.
1035                  */
1036                 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) {
1037                         lockmgr(&sc->aac_io_lock, LK_RELEASE);
1038                         aac_alloc_commands(sc);
1039                         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1040                         sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS;
1041                         aac_startio(sc);
1042                 }
1043
1044                 /*
1045                  * While we're here, check to see if any commands are stuck.
1046                  * This is pretty low-priority, so it's ok if it doesn't
1047                  * always fire.
1048                  */
1049                 if (retval == EWOULDBLOCK)
1050                         aac_timeout(sc);
1051
1052                 /* Check the hardware printf message buffer */
1053                 if (sc->aac_common->ac_printf[0] != 0)
1054                         aac_print_printf(sc);
1055
1056                 /* Also check to see if the adapter has a command for us. */
1057                 if (sc->flags & AAC_FLAGS_NEW_COMM)
1058                         continue;
1059                 for (;;) {
1060                         if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE,
1061                                            &fib_size, &fib))
1062                                 break;
1063
1064                         AAC_PRINT_FIB(sc, fib);
1065
1066                         switch (fib->Header.Command) {
1067                         case AifRequest:
1068                                 aac_handle_aif(sc, fib);
1069                                 break;
1070                         default:
1071                                 device_printf(sc->aac_dev, "unknown command "
1072                                               "from controller\n");
1073                                 break;
1074                         }
1075
1076                         if ((fib->Header.XferState == 0) ||
1077                             (fib->Header.StructType != AAC_FIBTYPE_TFIB)) {
1078                                 break;
1079                         }
1080
1081                         /* Return the AIF to the controller. */
1082                         if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) {
1083                                 fib->Header.XferState |= AAC_FIBSTATE_DONEHOST;
1084                                 *(AAC_FSAStatus*)fib->data = ST_OK;
1085
1086                                 /* XXX Compute the Size field? */
1087                                 size = fib->Header.Size;
1088                                 if (size > sizeof(struct aac_fib)) {
1089                                         size = sizeof(struct aac_fib);
1090                                         fib->Header.Size = size;
1091                                 }
1092                                 /*
1093                                  * Since we did not generate this command, it
1094                                  * cannot go through the normal
1095                                  * enqueue->startio chain.
1096                                  */
1097                                 aac_enqueue_response(sc,
1098                                                  AAC_ADAP_NORM_RESP_QUEUE,
1099                                                  fib);
1100                         }
1101                 }
1102         }
1103         sc->aifflags &= ~AAC_AIFFLAGS_RUNNING;
1104         lockmgr(&sc->aac_io_lock, LK_RELEASE);
1105         wakeup(sc->aac_dev);
1106 }
1107
1108 /*
1109  * Process completed commands.
1110  */
1111 static void
1112 aac_complete(void *context, int pending)
1113 {
1114         struct aac_softc *sc;
1115         struct aac_command *cm;
1116         struct aac_fib *fib;
1117         u_int32_t fib_size;
1118
1119         sc = (struct aac_softc *)context;
1120         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1121
1122         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1123
1124         /* pull completed commands off the queue */
1125         for (;;) {
1126                 /* look for completed FIBs on our queue */
1127                 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size,
1128                                                         &fib))
1129                         break;  /* nothing to do */
1130
1131                 /* get the command, unmap and hand off for processing */
1132                 cm = sc->aac_commands + fib->Header.SenderData;
1133                 if (cm == NULL) {
1134                         AAC_PRINT_FIB(sc, fib);
1135                         break;
1136                 }
1137                 if ((cm->cm_flags & AAC_CMD_TIMEDOUT) != 0)
1138                         device_printf(sc->aac_dev,
1139                             "COMMAND %p COMPLETED AFTER %d SECONDS\n",
1140                             cm, (int)(time_second-cm->cm_timestamp));
1141
1142                 aac_remove_busy(cm);
1143
1144                 aac_unmap_command(cm);
1145                 cm->cm_flags |= AAC_CMD_COMPLETED;
1146
1147                 /* is there a completion handler? */
1148                 if (cm->cm_complete != NULL) {
1149                         cm->cm_complete(cm);
1150                 } else {
1151                         /* assume that someone is sleeping on this command */
1152                         wakeup(cm);
1153                 }
1154         }
1155
1156         /* see if we can start some more I/O */
1157         sc->flags &= ~AAC_QUEUE_FRZN;
1158         aac_startio(sc);
1159
1160         lockmgr(&sc->aac_io_lock, LK_RELEASE);
1161 }
1162
1163 /*
1164  * Handle a bio submitted from a disk device.
1165  */
1166 void
1167 aac_submit_bio(struct aac_disk *ad, struct bio *bio)
1168 {
1169         struct aac_softc *sc;
1170
1171         bio->bio_driver_info = ad;
1172         sc = ad->ad_controller;
1173         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1174
1175         /* queue the BIO and try to get some work done */
1176         aac_enqueue_bio(sc, bio);
1177         aac_startio(sc);
1178 }
1179
1180 /*
1181  * Get a bio and build a command to go with it.
1182  */
1183 static int
1184 aac_bio_command(struct aac_softc *sc, struct aac_command **cmp)
1185 {
1186         struct aac_command *cm;
1187         struct aac_fib *fib;
1188         struct aac_disk *ad;
1189         struct bio *bio;
1190         struct buf *bp;
1191
1192         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1193
1194         /* get the resources we will need */
1195         cm = NULL;
1196         bio = NULL;
1197         if (aac_alloc_command(sc, &cm)) /* get a command */
1198                 goto fail;
1199         if ((bio = aac_dequeue_bio(sc)) == NULL)
1200                 goto fail;
1201
1202         /* fill out the command */
1203         bp = bio->bio_buf;
1204         cm->cm_data = (void *)bp->b_data;
1205         cm->cm_datalen = bp->b_bcount;
1206         cm->cm_complete = aac_bio_complete;
1207         cm->cm_private = bio;
1208         cm->cm_timestamp = time_second;
1209
1210         /* build the FIB */
1211         fib = cm->cm_fib;
1212         fib->Header.Size = sizeof(struct aac_fib_header);
1213         fib->Header.XferState =
1214                 AAC_FIBSTATE_HOSTOWNED   |
1215                 AAC_FIBSTATE_INITIALISED |
1216                 AAC_FIBSTATE_EMPTY       |
1217                 AAC_FIBSTATE_FROMHOST    |
1218                 AAC_FIBSTATE_REXPECTED   |
1219                 AAC_FIBSTATE_NORM        |
1220                 AAC_FIBSTATE_ASYNC       |
1221                 AAC_FIBSTATE_FAST_RESPONSE;
1222
1223         /* build the read/write request */
1224         ad = (struct aac_disk *)bio->bio_driver_info;
1225
1226         if (sc->flags & AAC_FLAGS_RAW_IO) {
1227                 struct aac_raw_io *raw;
1228                 raw = (struct aac_raw_io *)&fib->data[0];
1229                 fib->Header.Command = RawIo;
1230                 raw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1231                 raw->ByteCount = bp->b_bcount;
1232                 raw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1233                 raw->BpTotal = 0;
1234                 raw->BpComplete = 0;
1235                 fib->Header.Size += sizeof(struct aac_raw_io);
1236                 cm->cm_sgtable = (struct aac_sg_table *)&raw->SgMapRaw;
1237                 if (bp->b_cmd == BUF_CMD_READ) {
1238                         raw->Flags = 1;
1239                         cm->cm_flags |= AAC_CMD_DATAIN;
1240                 } else {
1241                         raw->Flags = 0;
1242                         cm->cm_flags |= AAC_CMD_DATAOUT;
1243                 }
1244         } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1245                 fib->Header.Command = ContainerCommand;
1246                 if (bp->b_cmd == BUF_CMD_READ) {
1247                         struct aac_blockread *br;
1248                         br = (struct aac_blockread *)&fib->data[0];
1249                         br->Command = VM_CtBlockRead;
1250                         br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1251                         br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1252                         br->ByteCount = bp->b_bcount;
1253                         fib->Header.Size += sizeof(struct aac_blockread);
1254                         cm->cm_sgtable = &br->SgMap;
1255                         cm->cm_flags |= AAC_CMD_DATAIN;
1256                 } else {
1257                         struct aac_blockwrite *bw;
1258                         bw = (struct aac_blockwrite *)&fib->data[0];
1259                         bw->Command = VM_CtBlockWrite;
1260                         bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1261                         bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1262                         bw->ByteCount = bp->b_bcount;
1263                         bw->Stable = CUNSTABLE;
1264                         fib->Header.Size += sizeof(struct aac_blockwrite);
1265                         cm->cm_flags |= AAC_CMD_DATAOUT;
1266                         cm->cm_sgtable = &bw->SgMap;
1267                 }
1268         } else {
1269                 fib->Header.Command = ContainerCommand64;
1270                 if (bp->b_cmd == BUF_CMD_READ) {
1271                         struct aac_blockread64 *br;
1272                         br = (struct aac_blockread64 *)&fib->data[0];
1273                         br->Command = VM_CtHostRead64;
1274                         br->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1275                         br->SectorCount = bp->b_bcount / AAC_BLOCK_SIZE;
1276                         br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1277                         br->Pad = 0;
1278                         br->Flags = 0;
1279                         fib->Header.Size += sizeof(struct aac_blockread64);
1280                         cm->cm_flags |= AAC_CMD_DATAIN;
1281                         cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64;
1282                 } else {
1283                         struct aac_blockwrite64 *bw;
1284                         bw = (struct aac_blockwrite64 *)&fib->data[0];
1285                         bw->Command = VM_CtHostWrite64;
1286                         bw->ContainerId = ad->ad_container->co_mntobj.ObjectId;
1287                         bw->SectorCount = bp->b_bcount / AAC_BLOCK_SIZE;
1288                         bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE;
1289                         bw->Pad = 0;
1290                         bw->Flags = 0;
1291                         fib->Header.Size += sizeof(struct aac_blockwrite64);
1292                         cm->cm_flags |= AAC_CMD_DATAOUT;
1293                         cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64;
1294                 }
1295         }
1296
1297         *cmp = cm;
1298         return(0);
1299
1300 fail:
1301         if (bio != NULL)
1302                 aac_enqueue_bio(sc, bio);
1303         if (cm != NULL)
1304                 aac_release_command(cm);
1305         return(ENOMEM);
1306 }
1307
1308 /*
1309  * Handle a bio-instigated command that has been completed.
1310  */
1311 static void
1312 aac_bio_complete(struct aac_command *cm)
1313 {
1314         struct aac_blockread_response *brr;
1315         struct aac_blockwrite_response *bwr;
1316         struct bio *bio;
1317         struct buf *bp;
1318         const char *code;
1319         AAC_FSAStatus status;
1320
1321         /* fetch relevant status and then release the command */
1322         bio = (struct bio *)cm->cm_private;
1323         bp = bio->bio_buf;
1324         if (bp->b_cmd == BUF_CMD_READ) {
1325                 brr = (struct aac_blockread_response *)&cm->cm_fib->data[0];
1326                 status = brr->Status;
1327         } else {
1328                 bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0];
1329                 status = bwr->Status;
1330         }
1331         aac_release_command(cm);
1332
1333         /* fix up the bio based on status */
1334         if (status == ST_OK) {
1335                 bp->b_resid = 0;
1336                 code = NULL;
1337         } else {
1338                 bp->b_error = EIO;
1339                 bp->b_flags |= B_ERROR;
1340                 /* pass an error string out to the disk layer */
1341                 code = aac_describe_code(aac_command_status_table, status);
1342         }
1343         aac_biodone(bio, code);
1344 }
1345
1346 /*
1347  * Submit a command to the controller, return when it completes.
1348  * XXX This is very dangerous!  If the card has gone out to lunch, we could
1349  *     be stuck here forever.  At the same time, signals are not caught
1350  *     because there is a risk that a signal could wakeup the sleep before
1351  *     the card has a chance to complete the command.  Since there is no way
1352  *     to cancel a command that is in progress, we can't protect against the
1353  *     card completing a command late and spamming the command and data
1354  *     memory.  So, we are held hostage until the command completes.
1355  */
1356 static int
1357 aac_wait_command(struct aac_command *cm)
1358 {
1359         struct aac_softc *sc;
1360         int error;
1361
1362         sc = cm->cm_sc;
1363         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1364
1365         /* Put the command on the ready queue and get things going */
1366         aac_enqueue_ready(cm);
1367         aac_startio(sc);
1368         error = lksleep(cm, &sc->aac_io_lock, 0, "aacwait", 0);
1369         return(error);
1370 }
1371
1372 /*
1373  *Command Buffer Management
1374  */
1375
1376 /*
1377  * Allocate a command.
1378  */
1379 int
1380 aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp)
1381 {
1382         struct aac_command *cm;
1383
1384         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1385
1386         if ((cm = aac_dequeue_free(sc)) == NULL) {
1387                 if (sc->total_fibs < sc->aac_max_fibs) {
1388                         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1389                         sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS;
1390                         lockmgr(&sc->aac_io_lock, LK_RELEASE);
1391                         wakeup(sc->aifthread);
1392                 }
1393                 return (EBUSY);
1394         }
1395
1396         *cmp = cm;
1397         return(0);
1398 }
1399
1400 /*
1401  * Release a command back to the freelist.
1402  */
1403 void
1404 aac_release_command(struct aac_command *cm)
1405 {
1406         struct aac_event *event;
1407         struct aac_softc *sc;
1408
1409         sc = cm->cm_sc;
1410         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1411
1412         /* (re)initialize the command/FIB */
1413         cm->cm_sgtable = NULL;
1414         cm->cm_flags = 0;
1415         cm->cm_complete = NULL;
1416         cm->cm_private = NULL;
1417         cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE;
1418         cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY;
1419         cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB;
1420         cm->cm_fib->Header.Flags = 0;
1421         cm->cm_fib->Header.SenderSize = cm->cm_sc->aac_max_fib_size;
1422
1423         /*
1424          * These are duplicated in aac_start to cover the case where an
1425          * intermediate stage may have destroyed them.  They're left
1426          * initialized here for debugging purposes only.
1427          */
1428         cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1429         cm->cm_fib->Header.SenderData = 0;
1430
1431         aac_enqueue_free(cm);
1432
1433         if ((event = TAILQ_FIRST(&sc->aac_ev_cmfree)) != NULL) {
1434                 TAILQ_REMOVE(&sc->aac_ev_cmfree, event, ev_links);
1435                 event->ev_callback(sc, event, event->ev_arg);
1436         }
1437 }
1438
1439 /*
1440  * Map helper for command/FIB allocation.
1441  */
1442 static void
1443 aac_map_command_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1444 {
1445         uint64_t        *fibphys;
1446
1447         fibphys = (uint64_t *)arg;
1448
1449         *fibphys = segs[0].ds_addr;
1450 }
1451
1452 /*
1453  * Allocate and initialize commands/FIBs for this adapter.
1454  */
1455 static int
1456 aac_alloc_commands(struct aac_softc *sc)
1457 {
1458         struct aac_command *cm;
1459         struct aac_fibmap *fm;
1460         uint64_t fibphys;
1461         int i, error;
1462
1463         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1464
1465         if (sc->total_fibs + sc->aac_max_fibs_alloc > sc->aac_max_fibs)
1466                 return (ENOMEM);
1467
1468         fm = kmalloc(sizeof(struct aac_fibmap), M_AACBUF, M_INTWAIT | M_ZERO);
1469
1470         /* allocate the FIBs in DMAable memory and load them */
1471         if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs,
1472                              BUS_DMA_NOWAIT, &fm->aac_fibmap)) {
1473                 device_printf(sc->aac_dev,
1474                               "Not enough contiguous memory available.\n");
1475                 kfree(fm, M_AACBUF);
1476                 return (ENOMEM);
1477         }
1478
1479         /* Ignore errors since this doesn't bounce */
1480         (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs,
1481                               sc->aac_max_fibs_alloc * sc->aac_max_fib_size,
1482                               aac_map_command_helper, &fibphys, 0);
1483
1484         /* initialize constant fields in the command structure */
1485         bzero(fm->aac_fibs, sc->aac_max_fibs_alloc * sc->aac_max_fib_size);
1486         for (i = 0; i < sc->aac_max_fibs_alloc; i++) {
1487                 cm = sc->aac_commands + sc->total_fibs;
1488                 fm->aac_commands = cm;
1489                 cm->cm_sc = sc;
1490                 cm->cm_fib = (struct aac_fib *)
1491                         ((u_int8_t *)fm->aac_fibs + i*sc->aac_max_fib_size);
1492                 cm->cm_fibphys = fibphys + i*sc->aac_max_fib_size;
1493                 cm->cm_index = sc->total_fibs;
1494
1495                 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0,
1496                                                &cm->cm_datamap)) != 0)
1497                         break;
1498                 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1499                 aac_release_command(cm);
1500                 sc->total_fibs++;
1501                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1502         }
1503
1504         if (i > 0) {
1505                 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
1506                 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link);
1507                 fwprintf(sc, HBA_FLAGS_DBG_COMM_B, "total_fibs= %d\n", sc->total_fibs);
1508                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
1509                 return (0);
1510         }
1511
1512         bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1513         bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1514         kfree(fm, M_AACBUF);
1515         return (ENOMEM);
1516 }
1517
1518 /*
1519  * Free FIBs owned by this adapter.
1520  */
1521 static void
1522 aac_free_commands(struct aac_softc *sc)
1523 {
1524         struct aac_fibmap *fm;
1525         struct aac_command *cm;
1526         int i;
1527
1528         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1529
1530         while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) {
1531
1532                 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link);
1533                 /*
1534                  * We check against total_fibs to handle partially
1535                  * allocated blocks.
1536                  */
1537                 for (i = 0; i < sc->aac_max_fibs_alloc && sc->total_fibs--; i++) {
1538                         cm = fm->aac_commands + i;
1539                         bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap);
1540                 }
1541                 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap);
1542                 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap);
1543                 kfree(fm, M_AACBUF);
1544         }
1545 }
1546
1547 /*
1548  * Command-mapping helper function - populate this command's s/g table.
1549  */
1550 static void
1551 aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1552 {
1553         struct aac_softc *sc;
1554         struct aac_command *cm;
1555         struct aac_fib *fib;
1556         int i;
1557
1558         cm = (struct aac_command *)arg;
1559         sc = cm->cm_sc;
1560         fib = cm->cm_fib;
1561         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1562
1563         /* copy into the FIB */
1564         if (cm->cm_sgtable != NULL) {
1565                 if (fib->Header.Command == RawIo) {
1566                         struct aac_sg_tableraw *sg;
1567                         sg = (struct aac_sg_tableraw *)cm->cm_sgtable;
1568                         sg->SgCount = nseg;
1569                         for (i = 0; i < nseg; i++) {
1570                                 sg->SgEntryRaw[i].SgAddress = segs[i].ds_addr;
1571                                 sg->SgEntryRaw[i].SgByteCount = segs[i].ds_len;
1572                                 sg->SgEntryRaw[i].Next = 0;
1573                                 sg->SgEntryRaw[i].Prev = 0;
1574                                 sg->SgEntryRaw[i].Flags = 0;
1575                         }
1576                         /* update the FIB size for the s/g count */
1577                         fib->Header.Size += nseg*sizeof(struct aac_sg_entryraw);
1578                 } else if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
1579                         struct aac_sg_table *sg;
1580                         sg = cm->cm_sgtable;
1581                         sg->SgCount = nseg;
1582                         for (i = 0; i < nseg; i++) {
1583                                 sg->SgEntry[i].SgAddress = segs[i].ds_addr;
1584                                 sg->SgEntry[i].SgByteCount = segs[i].ds_len;
1585                         }
1586                         /* update the FIB size for the s/g count */
1587                         fib->Header.Size += nseg*sizeof(struct aac_sg_entry);
1588                 } else {
1589                         struct aac_sg_table64 *sg;
1590                         sg = (struct aac_sg_table64 *)cm->cm_sgtable;
1591                         sg->SgCount = nseg;
1592                         for (i = 0; i < nseg; i++) {
1593                                 sg->SgEntry64[i].SgAddress = segs[i].ds_addr;
1594                                 sg->SgEntry64[i].SgByteCount = segs[i].ds_len;
1595                         }
1596                         /* update the FIB size for the s/g count */
1597                         fib->Header.Size += nseg*sizeof(struct aac_sg_entry64);
1598                 }
1599         }
1600
1601         /* Fix up the address values in the FIB.  Use the command array index
1602          * instead of a pointer since these fields are only 32 bits.  Shift
1603          * the SenderFibAddress over to make room for the fast response bit
1604          * and for the AIF bit
1605          */
1606         cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 2);
1607         cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys;
1608
1609         /* save a pointer to the command for speedy reverse-lookup */
1610         cm->cm_fib->Header.SenderData = cm->cm_index;
1611
1612         if (cm->cm_flags & AAC_CMD_DATAIN)
1613                 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1614                                 BUS_DMASYNC_PREREAD);
1615         if (cm->cm_flags & AAC_CMD_DATAOUT)
1616                 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1617                                 BUS_DMASYNC_PREWRITE);
1618         cm->cm_flags |= AAC_CMD_MAPPED;
1619
1620         if (sc->flags & AAC_FLAGS_NEW_COMM) {
1621                 int count = 10000000L;
1622                 while (AAC_SEND_COMMAND(sc, cm) != 0) {
1623                         if (--count == 0) {
1624                                 aac_unmap_command(cm);
1625                                 sc->flags |= AAC_QUEUE_FRZN;
1626                                 aac_requeue_ready(cm);
1627                         }
1628                         DELAY(5);                       /* wait 5 usec. */
1629                 }
1630         } else {
1631                 /* Put the FIB on the outbound queue */
1632                 if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) {
1633                         aac_unmap_command(cm);
1634                         sc->flags |= AAC_QUEUE_FRZN;
1635                         aac_requeue_ready(cm);
1636                 }
1637         }
1638
1639         return;
1640 }
1641
1642 /*
1643  * Unmap a command from controller-visible space.
1644  */
1645 static void
1646 aac_unmap_command(struct aac_command *cm)
1647 {
1648         struct aac_softc *sc;
1649
1650         sc = cm->cm_sc;
1651         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1652
1653         if (!(cm->cm_flags & AAC_CMD_MAPPED))
1654                 return;
1655
1656         if (cm->cm_datalen != 0) {
1657                 if (cm->cm_flags & AAC_CMD_DATAIN)
1658                         bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1659                                         BUS_DMASYNC_POSTREAD);
1660                 if (cm->cm_flags & AAC_CMD_DATAOUT)
1661                         bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap,
1662                                         BUS_DMASYNC_POSTWRITE);
1663
1664                 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap);
1665         }
1666         cm->cm_flags &= ~AAC_CMD_MAPPED;
1667 }
1668
1669 /*
1670  * Hardware Interface
1671  */
1672
1673 /*
1674  * Initialize the adapter.
1675  */
1676 static void
1677 aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1678 {
1679         struct aac_softc *sc;
1680
1681         sc = (struct aac_softc *)arg;
1682         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1683
1684         sc->aac_common_busaddr = segs[0].ds_addr;
1685 }
1686
1687 static int
1688 aac_check_firmware(struct aac_softc *sc)
1689 {
1690         u_int32_t code, major, minor, options = 0, atu_size = 0;
1691         int status;
1692         time_t then;
1693
1694         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1695         /*
1696          * Wait for the adapter to come ready.
1697          */
1698         then = time_second;
1699         do {
1700                 code = AAC_GET_FWSTATUS(sc);
1701                 if (code & AAC_SELF_TEST_FAILED) {
1702                         device_printf(sc->aac_dev, "FATAL: selftest failed\n");
1703                         return(ENXIO);
1704                 }
1705                 if (code & AAC_KERNEL_PANIC) {
1706                         device_printf(sc->aac_dev,
1707                                       "FATAL: controller kernel panic");
1708                         return(ENXIO);
1709                 }
1710                 if (time_second > (then + AAC_BOOT_TIMEOUT)) {
1711                         device_printf(sc->aac_dev,
1712                                       "FATAL: controller not coming ready, "
1713                                            "status %x\n", code);
1714                         return(ENXIO);
1715                 }
1716         } while (!(code & AAC_UP_AND_RUNNING));
1717
1718         /*
1719          * Retrieve the firmware version numbers.  Dell PERC2/QC cards with
1720          * firmware version 1.x are not compatible with this driver.
1721          */
1722         if (sc->flags & AAC_FLAGS_PERC2QC) {
1723                 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0,
1724                                      NULL)) {
1725                         device_printf(sc->aac_dev,
1726                                       "Error reading firmware version\n");
1727                         return (EIO);
1728                 }
1729
1730                 /* These numbers are stored as ASCII! */
1731                 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30;
1732                 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30;
1733                 if (major == 1) {
1734                         device_printf(sc->aac_dev,
1735                             "Firmware version %d.%d is not supported.\n",
1736                             major, minor);
1737                         return (EINVAL);
1738                 }
1739         }
1740
1741         /*
1742          * Retrieve the capabilities/supported options word so we know what
1743          * work-arounds to enable.  Some firmware revs don't support this
1744          * command.
1745          */
1746         if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, &status)) {
1747                 if (status != AAC_SRB_STS_INVALID_REQUEST) {
1748                         device_printf(sc->aac_dev,
1749                              "RequestAdapterInfo failed\n");
1750                         return (EIO);
1751                 }
1752         } else {
1753                 options = AAC_GET_MAILBOX(sc, 1);
1754                 atu_size = AAC_GET_MAILBOX(sc, 2);
1755                 sc->supported_options = options;
1756
1757                 if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 &&
1758                     (sc->flags & AAC_FLAGS_NO4GB) == 0)
1759                         sc->flags |= AAC_FLAGS_4GB_WINDOW;
1760                 if (options & AAC_SUPPORTED_NONDASD)
1761                         sc->flags |= AAC_FLAGS_ENABLE_CAM;
1762                 if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0
1763                      && (sizeof(bus_addr_t) > 4)) {
1764                         device_printf(sc->aac_dev,
1765                             "Enabling 64-bit address support\n");
1766                         sc->flags |= AAC_FLAGS_SG_64BIT;
1767                 }
1768                 if ((options & AAC_SUPPORTED_NEW_COMM)
1769                  && sc->aac_if.aif_send_command)
1770                         sc->flags |= AAC_FLAGS_NEW_COMM;
1771                 if (options & AAC_SUPPORTED_64BIT_ARRAYSIZE)
1772                         sc->flags |= AAC_FLAGS_ARRAY_64BIT;
1773         }
1774
1775         /* Check for broken hardware that does a lower number of commands */
1776         sc->aac_max_fibs = (sc->flags & AAC_FLAGS_256FIBS ? 256:512);
1777
1778         /* Remap mem. resource, if required */
1779         if ((sc->flags & AAC_FLAGS_NEW_COMM) &&
1780                 atu_size > rman_get_size(sc->aac_regs_res1)) {
1781                 bus_release_resource(
1782                         sc->aac_dev, SYS_RES_MEMORY,
1783                         sc->aac_regs_rid1, sc->aac_regs_res1);
1784                 sc->aac_regs_res1 = bus_alloc_resource(
1785                         sc->aac_dev, SYS_RES_MEMORY, &sc->aac_regs_rid1,
1786                         0ul, ~0ul, atu_size, RF_ACTIVE);
1787                 if (sc->aac_regs_res1 == NULL) {
1788                         sc->aac_regs_res1 = bus_alloc_resource_any(
1789                                 sc->aac_dev, SYS_RES_MEMORY,
1790                                 &sc->aac_regs_rid1, RF_ACTIVE);
1791                         if (sc->aac_regs_res1 == NULL) {
1792                                 device_printf(sc->aac_dev,
1793                                     "couldn't allocate register window\n");
1794                                 return (ENXIO);
1795                         }
1796                         sc->flags &= ~AAC_FLAGS_NEW_COMM;
1797                 }
1798                 sc->aac_btag1 = rman_get_bustag(sc->aac_regs_res1);
1799                 sc->aac_bhandle1 = rman_get_bushandle(sc->aac_regs_res1);
1800
1801                 if (sc->aac_hwif == AAC_HWIF_NARK) {
1802                         sc->aac_regs_res0 = sc->aac_regs_res1;
1803                         sc->aac_regs_rid0 = sc->aac_regs_rid1;
1804                         sc->aac_btag0 = sc->aac_btag1;
1805                         sc->aac_bhandle0 = sc->aac_bhandle1;
1806                 }
1807         }
1808
1809         /* Read preferred settings */
1810         sc->aac_max_fib_size = sizeof(struct aac_fib);
1811         sc->aac_max_sectors = 128;                              /* 64KB */
1812         if (sc->flags & AAC_FLAGS_SG_64BIT)
1813                 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1814                  - sizeof(struct aac_blockwrite64))
1815                  / sizeof(struct aac_sg_entry64);
1816         else
1817                 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE
1818                  - sizeof(struct aac_blockwrite))
1819                  / sizeof(struct aac_sg_entry);
1820
1821         if (!aac_sync_command(sc, AAC_MONKER_GETCOMMPREF, 0, 0, 0, 0, NULL)) {
1822                 options = AAC_GET_MAILBOX(sc, 1);
1823                 sc->aac_max_fib_size = (options & 0xFFFF);
1824                 sc->aac_max_sectors = (options >> 16) << 1;
1825                 options = AAC_GET_MAILBOX(sc, 2);
1826                 sc->aac_sg_tablesize = (options >> 16);
1827                 options = AAC_GET_MAILBOX(sc, 3);
1828                 sc->aac_max_fibs = (options & 0xFFFF);
1829         }
1830         if (sc->aac_max_fib_size > PAGE_SIZE)
1831                 sc->aac_max_fib_size = PAGE_SIZE;
1832         sc->aac_max_fibs_alloc = PAGE_SIZE / sc->aac_max_fib_size;
1833
1834         if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1835                 sc->flags |= AAC_FLAGS_RAW_IO;
1836                 device_printf(sc->aac_dev, "Enable Raw I/O\n");
1837         }
1838         if ((sc->flags & AAC_FLAGS_RAW_IO) &&
1839             (sc->flags & AAC_FLAGS_ARRAY_64BIT)) {
1840                 sc->flags |= AAC_FLAGS_LBA_64BIT;
1841                 device_printf(sc->aac_dev, "Enable 64-bit array\n");
1842         }
1843
1844         return (0);
1845 }
1846
1847 static int
1848 aac_init(struct aac_softc *sc)
1849 {
1850         struct aac_adapter_init *ip;
1851         u_int32_t qoffset;
1852         int error;
1853
1854         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
1855
1856         /*
1857          * Fill in the init structure.  This tells the adapter about the
1858          * physical location of various important shared data structures.
1859          */
1860         ip = &sc->aac_common->ac_init;
1861         ip->InitStructRevision = AAC_INIT_STRUCT_REVISION;
1862         if (sc->aac_max_fib_size > sizeof(struct aac_fib)) {
1863                 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_4;
1864                 sc->flags |= AAC_FLAGS_RAW_IO;
1865         }
1866         ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION;
1867
1868         ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr +
1869                                          offsetof(struct aac_common, ac_fibs);
1870         ip->AdapterFibsVirtualAddress = 0;
1871         ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib);
1872         ip->AdapterFibAlign = sizeof(struct aac_fib);
1873
1874         ip->PrintfBufferAddress = sc->aac_common_busaddr +
1875                                   offsetof(struct aac_common, ac_printf);
1876         ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE;
1877
1878         /*
1879          * The adapter assumes that pages are 4K in size, except on some
1880          * broken firmware versions that do the page->byte conversion twice,
1881          * therefore 'assuming' that this value is in 16MB units (2^24).
1882          * Round up since the granularity is so high.
1883          */
1884         ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE;
1885         if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) {
1886                 ip->HostPhysMemPages =
1887                     (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE;
1888         }
1889         ip->HostElapsedSeconds = time_second;   /* reset later if invalid */
1890
1891         ip->InitFlags = 0;
1892         if (sc->flags & AAC_FLAGS_NEW_COMM) {
1893                 ip->InitFlags |= AAC_INITFLAGS_NEW_COMM_SUPPORTED;
1894                 device_printf(sc->aac_dev, "New comm. interface enabled\n");
1895         }
1896
1897         ip->MaxIoCommands = sc->aac_max_fibs;
1898         ip->MaxIoSize = sc->aac_max_sectors << 9;
1899         ip->MaxFibSize = sc->aac_max_fib_size;
1900
1901         /*
1902          * Initialize FIB queues.  Note that it appears that the layout of the
1903          * indexes and the segmentation of the entries may be mandated by the
1904          * adapter, which is only told about the base of the queue index fields.
1905          *
1906          * The initial values of the indices are assumed to inform the adapter
1907          * of the sizes of the respective queues, and theoretically it could
1908          * work out the entire layout of the queue structures from this.  We
1909          * take the easy route and just lay this area out like everyone else
1910          * does.
1911          *
1912          * The Linux driver uses a much more complex scheme whereby several
1913          * header records are kept for each queue.  We use a couple of generic
1914          * list manipulation functions which 'know' the size of each list by
1915          * virtue of a table.
1916          */
1917         qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN;
1918         qoffset &= ~(AAC_QUEUE_ALIGN - 1);
1919         sc->aac_queues =
1920             (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset);
1921         ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset;
1922
1923         sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1924                 AAC_HOST_NORM_CMD_ENTRIES;
1925         sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1926                 AAC_HOST_NORM_CMD_ENTRIES;
1927         sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1928                 AAC_HOST_HIGH_CMD_ENTRIES;
1929         sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1930                 AAC_HOST_HIGH_CMD_ENTRIES;
1931         sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1932                 AAC_ADAP_NORM_CMD_ENTRIES;
1933         sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1934                 AAC_ADAP_NORM_CMD_ENTRIES;
1935         sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] =
1936                 AAC_ADAP_HIGH_CMD_ENTRIES;
1937         sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] =
1938                 AAC_ADAP_HIGH_CMD_ENTRIES;
1939         sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1940                 AAC_HOST_NORM_RESP_ENTRIES;
1941         sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1942                 AAC_HOST_NORM_RESP_ENTRIES;
1943         sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1944                 AAC_HOST_HIGH_RESP_ENTRIES;
1945         sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1946                 AAC_HOST_HIGH_RESP_ENTRIES;
1947         sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1948                 AAC_ADAP_NORM_RESP_ENTRIES;
1949         sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1950                 AAC_ADAP_NORM_RESP_ENTRIES;
1951         sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]=
1952                 AAC_ADAP_HIGH_RESP_ENTRIES;
1953         sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]=
1954                 AAC_ADAP_HIGH_RESP_ENTRIES;
1955         sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] =
1956                 &sc->aac_queues->qt_HostNormCmdQueue[0];
1957         sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] =
1958                 &sc->aac_queues->qt_HostHighCmdQueue[0];
1959         sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] =
1960                 &sc->aac_queues->qt_AdapNormCmdQueue[0];
1961         sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] =
1962                 &sc->aac_queues->qt_AdapHighCmdQueue[0];
1963         sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] =
1964                 &sc->aac_queues->qt_HostNormRespQueue[0];
1965         sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] =
1966                 &sc->aac_queues->qt_HostHighRespQueue[0];
1967         sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] =
1968                 &sc->aac_queues->qt_AdapNormRespQueue[0];
1969         sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] =
1970                 &sc->aac_queues->qt_AdapHighRespQueue[0];
1971
1972         /*
1973          * Do controller-type-specific initialisation
1974          */
1975         switch (sc->aac_hwif) {
1976         case AAC_HWIF_I960RX:
1977                 AAC_MEM0_SETREG4(sc, AAC_RX_ODBR, ~0);
1978                 break;
1979         case AAC_HWIF_RKT:
1980                 AAC_MEM0_SETREG4(sc, AAC_RKT_ODBR, ~0);
1981                 break;
1982         default:
1983                 break;
1984         }
1985
1986         /*
1987          * Give the init structure to the controller.
1988          */
1989         if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT,
1990                              sc->aac_common_busaddr +
1991                              offsetof(struct aac_common, ac_init), 0, 0, 0,
1992                              NULL)) {
1993                 device_printf(sc->aac_dev,
1994                               "error establishing init structure\n");
1995                 error = EIO;
1996                 goto out;
1997         }
1998
1999         error = 0;
2000 out:
2001         return(error);
2002 }
2003
2004 static int
2005 aac_setup_intr(struct aac_softc *sc)
2006 {
2007         sc->aac_irq_rid = 0;
2008         if ((sc->aac_irq = bus_alloc_resource_any(sc->aac_dev, SYS_RES_IRQ,
2009                                                   &sc->aac_irq_rid,
2010                                                   RF_SHAREABLE |
2011                                                   RF_ACTIVE)) == NULL) {
2012                 device_printf(sc->aac_dev, "can't allocate interrupt\n");
2013                 return (EINVAL);
2014         }
2015         if (sc->flags & AAC_FLAGS_NEW_COMM) {
2016                 if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
2017                                    INTR_MPSAFE,
2018                                    aac_new_intr, sc, &sc->aac_intr, NULL)) {
2019                         device_printf(sc->aac_dev, "can't set up interrupt\n");
2020                         return (EINVAL);
2021                 }
2022         } else {
2023                 if (bus_setup_intr(sc->aac_dev, sc->aac_irq,
2024                                    0, aac_filter,
2025                                    sc, &sc->aac_intr, NULL)) {
2026                         device_printf(sc->aac_dev,
2027                                       "can't set up interrupt filter\n");
2028                         return (EINVAL);
2029                 }
2030         }
2031         return (0);
2032 }
2033
2034 /*
2035  * Send a synchronous command to the controller and wait for a result.
2036  * Indicate if the controller completed the command with an error status.
2037  */
2038 static int
2039 aac_sync_command(struct aac_softc *sc, u_int32_t command,
2040                  u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3,
2041                  u_int32_t *sp)
2042 {
2043         time_t then;
2044         u_int32_t status;
2045
2046         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2047
2048         /* populate the mailbox */
2049         AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3);
2050
2051         /* ensure the sync command doorbell flag is cleared */
2052         AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2053
2054         /* then set it to signal the adapter */
2055         AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND);
2056
2057         /* spin waiting for the command to complete */
2058         then = time_second;
2059         do {
2060                 if (time_second > (then + AAC_IMMEDIATE_TIMEOUT)) {
2061                         fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "timed out");
2062                         return(EIO);
2063                 }
2064         } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND));
2065
2066         /* clear the completion flag */
2067         AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND);
2068
2069         /* get the command status */
2070         status = AAC_GET_MAILBOX(sc, 0);
2071         if (sp != NULL)
2072                 *sp = status;
2073
2074         if (status != AAC_SRB_STS_SUCCESS)
2075                 return (-1);
2076         return(0);
2077 }
2078
2079 int
2080 aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate,
2081                  struct aac_fib *fib, u_int16_t datasize)
2082 {
2083         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2084 #if 0 /* XXX swildner */
2085         KKASSERT(lockstatus(&sc->aac_io_lock, curthread) != 0);
2086 #endif
2087
2088         if (datasize > AAC_FIB_DATASIZE)
2089                 return(EINVAL);
2090
2091         /*
2092          * Set up the sync FIB
2093          */
2094         fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED |
2095                                 AAC_FIBSTATE_INITIALISED |
2096                                 AAC_FIBSTATE_EMPTY;
2097         fib->Header.XferState |= xferstate;
2098         fib->Header.Command = command;
2099         fib->Header.StructType = AAC_FIBTYPE_TFIB;
2100         fib->Header.Size = sizeof(struct aac_fib_header) + datasize;
2101         fib->Header.SenderSize = sizeof(struct aac_fib);
2102         fib->Header.SenderFibAddress = 0;       /* Not needed */
2103         fib->Header.ReceiverFibAddress = sc->aac_common_busaddr +
2104                                          offsetof(struct aac_common,
2105                                                   ac_sync_fib);
2106
2107         /*
2108          * Give the FIB to the controller, wait for a response.
2109          */
2110         if (aac_sync_command(sc, AAC_MONKER_SYNCFIB,
2111                              fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) {
2112                 fwprintf(sc, HBA_FLAGS_DBG_ERROR_B, "IO error");
2113                 return(EIO);
2114         }
2115
2116         return (0);
2117 }
2118
2119 /*
2120  * Adapter-space FIB queue manipulation
2121  *
2122  * Note that the queue implementation here is a little funky; neither the PI or
2123  * CI will ever be zero.  This behaviour is a controller feature.
2124  */
2125 static struct {
2126         int             size;
2127         int             notify;
2128 } aac_qinfo[] = {
2129         {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL},
2130         {AAC_HOST_HIGH_CMD_ENTRIES, 0},
2131         {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY},
2132         {AAC_ADAP_HIGH_CMD_ENTRIES, 0},
2133         {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL},
2134         {AAC_HOST_HIGH_RESP_ENTRIES, 0},
2135         {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY},
2136         {AAC_ADAP_HIGH_RESP_ENTRIES, 0}
2137 };
2138
2139 /*
2140  * Atomically insert an entry into the nominated queue, returns 0 on success or
2141  * EBUSY if the queue is full.
2142  *
2143  * Note: it would be more efficient to defer notifying the controller in
2144  *       the case where we may be inserting several entries in rapid succession,
2145  *       but implementing this usefully may be difficult (it would involve a
2146  *       separate queue/notify interface).
2147  */
2148 static int
2149 aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm)
2150 {
2151         u_int32_t pi, ci;
2152         int error;
2153         u_int32_t fib_size;
2154         u_int32_t fib_addr;
2155
2156         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2157
2158         fib_size = cm->cm_fib->Header.Size;
2159         fib_addr = cm->cm_fib->Header.ReceiverFibAddress;
2160
2161         /* get the producer/consumer indices */
2162         pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2163         ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2164
2165         /* wrap the queue? */
2166         if (pi >= aac_qinfo[queue].size)
2167                 pi = 0;
2168
2169         /* check for queue full */
2170         if ((pi + 1) == ci) {
2171                 error = EBUSY;
2172                 goto out;
2173         }
2174
2175         /*
2176          * To avoid a race with its completion interrupt, place this command on
2177          * the busy queue prior to advertising it to the controller.
2178          */
2179         aac_enqueue_busy(cm);
2180
2181         /* populate queue entry */
2182         (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2183         (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2184
2185         /* update producer index */
2186         sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2187
2188         /* notify the adapter if we know how */
2189         if (aac_qinfo[queue].notify != 0)
2190                 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2191
2192         error = 0;
2193
2194 out:
2195         return(error);
2196 }
2197
2198 /*
2199  * Atomically remove one entry from the nominated queue, returns 0 on
2200  * success or ENOENT if the queue is empty.
2201  */
2202 static int
2203 aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size,
2204                 struct aac_fib **fib_addr)
2205 {
2206         u_int32_t pi, ci;
2207         u_int32_t fib_index;
2208         int error;
2209         int notify;
2210
2211         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2212
2213         /* get the producer/consumer indices */
2214         pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2215         ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2216
2217         /* check for queue empty */
2218         if (ci == pi) {
2219                 error = ENOENT;
2220                 goto out;
2221         }
2222
2223         /* wrap the pi so the following test works */
2224         if (pi >= aac_qinfo[queue].size)
2225                 pi = 0;
2226
2227         notify = 0;
2228         if (ci == pi + 1)
2229                 notify++;
2230
2231         /* wrap the queue? */
2232         if (ci >= aac_qinfo[queue].size)
2233                 ci = 0;
2234
2235         /* fetch the entry */
2236         *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size;
2237
2238         switch (queue) {
2239         case AAC_HOST_NORM_CMD_QUEUE:
2240         case AAC_HOST_HIGH_CMD_QUEUE:
2241                 /*
2242                  * The aq_fib_addr is only 32 bits wide so it can't be counted
2243                  * on to hold an address.  For AIF's, the adapter assumes
2244                  * that it's giving us an address into the array of AIF fibs.
2245                  * Therefore, we have to convert it to an index.
2246                  */
2247                 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr /
2248                         sizeof(struct aac_fib);
2249                 *fib_addr = &sc->aac_common->ac_fibs[fib_index];
2250                 break;
2251
2252         case AAC_HOST_NORM_RESP_QUEUE:
2253         case AAC_HOST_HIGH_RESP_QUEUE:
2254         {
2255                 struct aac_command *cm;
2256
2257                 /*
2258                  * As above, an index is used instead of an actual address.
2259                  * Gotta shift the index to account for the fast response
2260                  * bit.  No other correction is needed since this value was
2261                  * originally provided by the driver via the SenderFibAddress
2262                  * field.
2263                  */
2264                 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr;
2265                 cm = sc->aac_commands + (fib_index >> 2);
2266                 *fib_addr = cm->cm_fib;
2267
2268                 /*
2269                  * Is this a fast response? If it is, update the fib fields in
2270                  * local memory since the whole fib isn't DMA'd back up.
2271                  */
2272                 if (fib_index & 0x01) {
2273                         (*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP;
2274                         *((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL;
2275                 }
2276                 break;
2277         }
2278         default:
2279                 panic("Invalid queue in aac_dequeue_fib()");
2280                 break;
2281         }
2282
2283         /* update consumer index */
2284         sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1;
2285
2286         /* if we have made the queue un-full, notify the adapter */
2287         if (notify && (aac_qinfo[queue].notify != 0))
2288                 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2289         error = 0;
2290
2291 out:
2292         return(error);
2293 }
2294
2295 /*
2296  * Put our response to an Adapter Initialed Fib on the response queue
2297  */
2298 static int
2299 aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib)
2300 {
2301         u_int32_t pi, ci;
2302         int error;
2303         u_int32_t fib_size;
2304         u_int32_t fib_addr;
2305
2306         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2307
2308         /* Tell the adapter where the FIB is */
2309         fib_size = fib->Header.Size;
2310         fib_addr = fib->Header.SenderFibAddress;
2311         fib->Header.ReceiverFibAddress = fib_addr;
2312
2313         /* get the producer/consumer indices */
2314         pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX];
2315         ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX];
2316
2317         /* wrap the queue? */
2318         if (pi >= aac_qinfo[queue].size)
2319                 pi = 0;
2320
2321         /* check for queue full */
2322         if ((pi + 1) == ci) {
2323                 error = EBUSY;
2324                 goto out;
2325         }
2326
2327         /* populate queue entry */
2328         (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size;
2329         (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr;
2330
2331         /* update producer index */
2332         sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1;
2333
2334         /* notify the adapter if we know how */
2335         if (aac_qinfo[queue].notify != 0)
2336                 AAC_QNOTIFY(sc, aac_qinfo[queue].notify);
2337
2338         error = 0;
2339
2340 out:
2341         return(error);
2342 }
2343
2344 /*
2345  * Check for commands that have been outstanding for a suspiciously long time,
2346  * and complain about them.
2347  */
2348 static void
2349 aac_timeout(struct aac_softc *sc)
2350 {
2351         struct aac_command *cm;
2352         time_t deadline;
2353         int timedout, code;
2354
2355         /*
2356          * Traverse the busy command list, bitch about late commands once
2357          * only.
2358          */
2359         timedout = 0;
2360         deadline = time_second - AAC_CMD_TIMEOUT;
2361         TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) {
2362                 if ((cm->cm_timestamp  < deadline)
2363                     && !(cm->cm_flags & AAC_CMD_TIMEDOUT)) {
2364                         cm->cm_flags |= AAC_CMD_TIMEDOUT;
2365                         device_printf(sc->aac_dev,
2366                             "COMMAND %p (TYPE %d) TIMEOUT AFTER %d SECONDS\n",
2367                             cm, cm->cm_fib->Header.Command,
2368                             (int)(time_second-cm->cm_timestamp));
2369                         AAC_PRINT_FIB(sc, cm->cm_fib);
2370                         timedout++;
2371                 }
2372         }
2373
2374         if (timedout) {
2375                 code = AAC_GET_FWSTATUS(sc);
2376                 if (code != AAC_UP_AND_RUNNING) {
2377                         device_printf(sc->aac_dev, "WARNING! Controller is no "
2378                                       "longer running! code= 0x%x\n", code);
2379                 }
2380         }
2381         return;
2382 }
2383
2384 /*
2385  * Interface Function Vectors
2386  */
2387
2388 /*
2389  * Read the current firmware status word.
2390  */
2391 static int
2392 aac_sa_get_fwstatus(struct aac_softc *sc)
2393 {
2394         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2395
2396         return(AAC_MEM0_GETREG4(sc, AAC_SA_FWSTATUS));
2397 }
2398
2399 static int
2400 aac_rx_get_fwstatus(struct aac_softc *sc)
2401 {
2402         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2403
2404         return(AAC_MEM0_GETREG4(sc, sc->flags & AAC_FLAGS_NEW_COMM ?
2405             AAC_RX_OMR0 : AAC_RX_FWSTATUS));
2406 }
2407
2408 static int
2409 aac_rkt_get_fwstatus(struct aac_softc *sc)
2410 {
2411         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2412
2413         return(AAC_MEM0_GETREG4(sc, sc->flags & AAC_FLAGS_NEW_COMM ?
2414             AAC_RKT_OMR0 : AAC_RKT_FWSTATUS));
2415 }
2416
2417 /*
2418  * Notify the controller of a change in a given queue
2419  */
2420
2421 static void
2422 aac_sa_qnotify(struct aac_softc *sc, int qbit)
2423 {
2424         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2425
2426         AAC_MEM0_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit);
2427 }
2428
2429 static void
2430 aac_rx_qnotify(struct aac_softc *sc, int qbit)
2431 {
2432         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2433
2434         AAC_MEM0_SETREG4(sc, AAC_RX_IDBR, qbit);
2435 }
2436
2437 static void
2438 aac_rkt_qnotify(struct aac_softc *sc, int qbit)
2439 {
2440         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2441
2442         AAC_MEM0_SETREG4(sc, AAC_RKT_IDBR, qbit);
2443 }
2444
2445 /*
2446  * Get the interrupt reason bits
2447  */
2448 static int
2449 aac_sa_get_istatus(struct aac_softc *sc)
2450 {
2451         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2452
2453         return(AAC_MEM0_GETREG2(sc, AAC_SA_DOORBELL0));
2454 }
2455
2456 static int
2457 aac_rx_get_istatus(struct aac_softc *sc)
2458 {
2459         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2460
2461         return(AAC_MEM0_GETREG4(sc, AAC_RX_ODBR));
2462 }
2463
2464 static int
2465 aac_rkt_get_istatus(struct aac_softc *sc)
2466 {
2467         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2468
2469         return(AAC_MEM0_GETREG4(sc, AAC_RKT_ODBR));
2470 }
2471
2472 /*
2473  * Clear some interrupt reason bits
2474  */
2475 static void
2476 aac_sa_clear_istatus(struct aac_softc *sc, int mask)
2477 {
2478         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2479
2480         AAC_MEM0_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask);
2481 }
2482
2483 static void
2484 aac_rx_clear_istatus(struct aac_softc *sc, int mask)
2485 {
2486         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2487
2488         AAC_MEM0_SETREG4(sc, AAC_RX_ODBR, mask);
2489 }
2490
2491 static void
2492 aac_rkt_clear_istatus(struct aac_softc *sc, int mask)
2493 {
2494         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2495
2496         AAC_MEM0_SETREG4(sc, AAC_RKT_ODBR, mask);
2497 }
2498
2499 /*
2500  * Populate the mailbox and set the command word
2501  */
2502 static void
2503 aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command,
2504                 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2505 {
2506         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2507
2508         AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX, command);
2509         AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0);
2510         AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1);
2511         AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2);
2512         AAC_MEM1_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3);
2513 }
2514
2515 static void
2516 aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command,
2517                 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2518 {
2519         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2520
2521         AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX, command);
2522         AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0);
2523         AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1);
2524         AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2);
2525         AAC_MEM1_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3);
2526 }
2527
2528 static void
2529 aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0,
2530                     u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
2531 {
2532         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2533
2534         AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX, command);
2535         AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 4, arg0);
2536         AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 8, arg1);
2537         AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 12, arg2);
2538         AAC_MEM1_SETREG4(sc, AAC_RKT_MAILBOX + 16, arg3);
2539 }
2540
2541 /*
2542  * Fetch the immediate command status word
2543  */
2544 static int
2545 aac_sa_get_mailbox(struct aac_softc *sc, int mb)
2546 {
2547         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2548
2549         return(AAC_MEM1_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4)));
2550 }
2551
2552 static int
2553 aac_rx_get_mailbox(struct aac_softc *sc, int mb)
2554 {
2555         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2556
2557         return(AAC_MEM1_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4)));
2558 }
2559
2560 static int
2561 aac_rkt_get_mailbox(struct aac_softc *sc, int mb)
2562 {
2563         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2564
2565         return(AAC_MEM1_GETREG4(sc, AAC_RKT_MAILBOX + (mb * 4)));
2566 }
2567
2568 /*
2569  * Set/clear interrupt masks
2570  */
2571 static void
2572 aac_sa_set_interrupts(struct aac_softc *sc, int enable)
2573 {
2574         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2575
2576         if (enable) {
2577                 AAC_MEM0_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS);
2578         } else {
2579                 AAC_MEM0_SETREG2((sc), AAC_SA_MASK0_SET, ~0);
2580         }
2581 }
2582
2583 static void
2584 aac_rx_set_interrupts(struct aac_softc *sc, int enable)
2585 {
2586         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2587
2588         if (enable) {
2589                 if (sc->flags & AAC_FLAGS_NEW_COMM)
2590                         AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INT_NEW_COMM);
2591                 else
2592                         AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS);
2593         } else {
2594                 AAC_MEM0_SETREG4(sc, AAC_RX_OIMR, ~0);
2595         }
2596 }
2597
2598 static void
2599 aac_rkt_set_interrupts(struct aac_softc *sc, int enable)
2600 {
2601         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "%sable interrupts", enable ? "en" : "dis");
2602
2603         if (enable) {
2604                 if (sc->flags & AAC_FLAGS_NEW_COMM)
2605                         AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INT_NEW_COMM);
2606                 else
2607                         AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INTERRUPTS);
2608         } else {
2609                 AAC_MEM0_SETREG4(sc, AAC_RKT_OIMR, ~0);
2610         }
2611 }
2612
2613 /*
2614  * New comm. interface: Send command functions
2615  */
2616 static int
2617 aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm)
2618 {
2619         u_int32_t index, device;
2620
2621         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "send command (new comm.)");
2622
2623         index = AAC_MEM0_GETREG4(sc, AAC_RX_IQUE);
2624         if (index == 0xffffffffL)
2625                 index = AAC_MEM0_GETREG4(sc, AAC_RX_IQUE);
2626         if (index == 0xffffffffL)
2627                 return index;
2628         aac_enqueue_busy(cm);
2629         device = index;
2630         AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2631         device += 4;
2632         AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2633         device += 4;
2634         AAC_MEM1_SETREG4(sc, device, cm->cm_fib->Header.Size);
2635         AAC_MEM0_SETREG4(sc, AAC_RX_IQUE, index);
2636         return 0;
2637 }
2638
2639 static int
2640 aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm)
2641 {
2642         u_int32_t index, device;
2643
2644         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "send command (new comm.)");
2645
2646         index = AAC_MEM0_GETREG4(sc, AAC_RKT_IQUE);
2647         if (index == 0xffffffffL)
2648                 index = AAC_MEM0_GETREG4(sc, AAC_RKT_IQUE);
2649         if (index == 0xffffffffL)
2650                 return index;
2651         aac_enqueue_busy(cm);
2652         device = index;
2653         AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL));
2654         device += 4;
2655         AAC_MEM1_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32));
2656         device += 4;
2657         AAC_MEM1_SETREG4(sc, device, cm->cm_fib->Header.Size);
2658         AAC_MEM0_SETREG4(sc, AAC_RKT_IQUE, index);
2659         return 0;
2660 }
2661
2662 /*
2663  * New comm. interface: get, set outbound queue index
2664  */
2665 static int
2666 aac_rx_get_outb_queue(struct aac_softc *sc)
2667 {
2668         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2669
2670         return(AAC_MEM0_GETREG4(sc, AAC_RX_OQUE));
2671 }
2672
2673 static int
2674 aac_rkt_get_outb_queue(struct aac_softc *sc)
2675 {
2676         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2677
2678         return(AAC_MEM0_GETREG4(sc, AAC_RKT_OQUE));
2679 }
2680
2681 static void
2682 aac_rx_set_outb_queue(struct aac_softc *sc, int index)
2683 {
2684         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2685
2686         AAC_MEM0_SETREG4(sc, AAC_RX_OQUE, index);
2687 }
2688
2689 static void
2690 aac_rkt_set_outb_queue(struct aac_softc *sc, int index)
2691 {
2692         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2693
2694         AAC_MEM0_SETREG4(sc, AAC_RKT_OQUE, index);
2695 }
2696
2697 /*
2698  * Debugging and Diagnostics
2699  */
2700
2701 /*
2702  * Print some information about the controller.
2703  */
2704 static void
2705 aac_describe_controller(struct aac_softc *sc)
2706 {
2707         struct aac_fib *fib;
2708         struct aac_adapter_info *info;
2709         char *adapter_type = "Adaptec RAID controller";
2710
2711         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2712
2713         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
2714         aac_alloc_sync_fib(sc, &fib);
2715
2716         fib->data[0] = 0;
2717         if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) {
2718                 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n");
2719                 aac_release_sync_fib(sc);
2720                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
2721                 return;
2722         }
2723
2724         /* save the kernel revision structure for later use */
2725         info = (struct aac_adapter_info *)&fib->data[0];
2726         sc->aac_revision = info->KernelRevision;
2727
2728         if (bootverbose) {
2729                 device_printf(sc->aac_dev, "%s %dMHz, %dMB memory "
2730                     "(%dMB cache, %dMB execution), %s\n",
2731                     aac_describe_code(aac_cpu_variant, info->CpuVariant),
2732                     info->ClockSpeed, info->TotalMem / (1024 * 1024),
2733                     info->BufferMem / (1024 * 1024),
2734                     info->ExecutionMem / (1024 * 1024),
2735                     aac_describe_code(aac_battery_platform,
2736                     info->batteryPlatform));
2737
2738                 device_printf(sc->aac_dev,
2739                     "Kernel %d.%d-%d, Build %d, S/N %6X\n",
2740                     info->KernelRevision.external.comp.major,
2741                     info->KernelRevision.external.comp.minor,
2742                     info->KernelRevision.external.comp.dash,
2743                     info->KernelRevision.buildNumber,
2744                     (u_int32_t)(info->SerialNumber & 0xffffff));
2745
2746                 device_printf(sc->aac_dev, "Supported Options=%b\n",
2747                               sc->supported_options,
2748                               "\20"
2749                               "\1SNAPSHOT"
2750                               "\2CLUSTERS"
2751                               "\3WCACHE"
2752                               "\4DATA64"
2753                               "\5HOSTTIME"
2754                               "\6RAID50"
2755                               "\7WINDOW4GB"
2756                               "\10SCSIUPGD"
2757                               "\11SOFTERR"
2758                               "\12NORECOND"
2759                               "\13SGMAP64"
2760                               "\14ALARM"
2761                               "\15NONDASD"
2762                               "\16SCSIMGT"
2763                               "\17RAIDSCSI"
2764                               "\21ADPTINFO"
2765                               "\22NEWCOMM"
2766                               "\23ARRAY64BIT"
2767                               "\24HEATSENSOR");
2768         }
2769
2770         if (sc->supported_options & AAC_SUPPORTED_SUPPLEMENT_ADAPTER_INFO) {
2771                 fib->data[0] = 0;
2772                 if (aac_sync_fib(sc, RequestSupplementAdapterInfo, 0, fib, 1))
2773                         device_printf(sc->aac_dev,
2774                             "RequestSupplementAdapterInfo failed\n");
2775                 else
2776                         adapter_type = ((struct aac_supplement_adapter_info *)
2777                             &fib->data[0])->AdapterTypeText;
2778         }
2779         device_printf(sc->aac_dev, "%s, aac driver %d.%d.%d-%d\n",
2780                 adapter_type,
2781                 AAC_DRIVER_MAJOR_VERSION, AAC_DRIVER_MINOR_VERSION,
2782                 AAC_DRIVER_BUGFIX_LEVEL, AAC_DRIVER_BUILD);
2783
2784         aac_release_sync_fib(sc);
2785         lockmgr(&sc->aac_io_lock, LK_RELEASE);
2786 }
2787
2788 /*
2789  * Look up a text description of a numeric error code and return a pointer to
2790  * same.
2791  */
2792 static char *
2793 aac_describe_code(struct aac_code_lookup *table, u_int32_t code)
2794 {
2795         int i;
2796
2797         for (i = 0; table[i].string != NULL; i++)
2798                 if (table[i].code == code)
2799                         return(table[i].string);
2800         return(table[i + 1].string);
2801 }
2802
2803 /*
2804  * Management Interface
2805  */
2806
2807 static int
2808 aac_open(struct dev_open_args *ap)
2809 {
2810         cdev_t dev = ap->a_head.a_dev;
2811         struct aac_softc *sc;
2812
2813         sc = dev->si_drv1;
2814         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2815         device_busy(sc->aac_dev);
2816
2817         return 0;
2818 }
2819
2820 static int
2821 aac_ioctl(struct dev_ioctl_args *ap)
2822 {
2823         caddr_t arg = ap->a_data;
2824         cdev_t dev = ap->a_head.a_dev;
2825         u_long cmd = ap->a_cmd;
2826         union aac_statrequest *as;
2827         struct aac_softc *sc;
2828         int error = 0;
2829
2830         as = (union aac_statrequest *)arg;
2831         sc = dev->si_drv1;
2832         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
2833
2834         switch (cmd) {
2835         case AACIO_STATS:
2836                 switch (as->as_item) {
2837                 case AACQ_FREE:
2838                 case AACQ_BIO:
2839                 case AACQ_READY:
2840                 case AACQ_BUSY:
2841                         bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat,
2842                               sizeof(struct aac_qstat));
2843                         break;
2844                 default:
2845                         error = ENOENT;
2846                         break;
2847                 }
2848         break;
2849
2850         case FSACTL_SENDFIB:
2851         case FSACTL_SEND_LARGE_FIB:
2852                 arg = *(caddr_t*)arg;
2853         case FSACTL_LNX_SENDFIB:
2854         case FSACTL_LNX_SEND_LARGE_FIB:
2855                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_SENDFIB");
2856                 error = aac_ioctl_sendfib(sc, arg);
2857                 break;
2858         case FSACTL_SEND_RAW_SRB:
2859                 arg = *(caddr_t*)arg;
2860         case FSACTL_LNX_SEND_RAW_SRB:
2861                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_SEND_RAW_SRB");
2862                 error = aac_ioctl_send_raw_srb(sc, arg);
2863                 break;
2864         case FSACTL_AIF_THREAD:
2865         case FSACTL_LNX_AIF_THREAD:
2866                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_AIF_THREAD");
2867                 error = EINVAL;
2868                 break;
2869         case FSACTL_OPEN_GET_ADAPTER_FIB:
2870                 arg = *(caddr_t*)arg;
2871         case FSACTL_LNX_OPEN_GET_ADAPTER_FIB:
2872                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_OPEN_GET_ADAPTER_FIB");
2873                 error = aac_open_aif(sc, arg);
2874                 break;
2875         case FSACTL_GET_NEXT_ADAPTER_FIB:
2876                 arg = *(caddr_t*)arg;
2877         case FSACTL_LNX_GET_NEXT_ADAPTER_FIB:
2878                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_NEXT_ADAPTER_FIB");
2879                 error = aac_getnext_aif(sc, arg);
2880                 break;
2881         case FSACTL_CLOSE_GET_ADAPTER_FIB:
2882                 arg = *(caddr_t*)arg;
2883         case FSACTL_LNX_CLOSE_GET_ADAPTER_FIB:
2884                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_CLOSE_GET_ADAPTER_FIB");
2885                 error = aac_close_aif(sc, arg);
2886                 break;
2887         case FSACTL_MINIPORT_REV_CHECK:
2888                 arg = *(caddr_t*)arg;
2889         case FSACTL_LNX_MINIPORT_REV_CHECK:
2890                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_MINIPORT_REV_CHECK");
2891                 error = aac_rev_check(sc, arg);
2892                 break;
2893         case FSACTL_QUERY_DISK:
2894                 arg = *(caddr_t*)arg;
2895         case FSACTL_LNX_QUERY_DISK:
2896                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_QUERY_DISK");
2897                 error = aac_query_disk(sc, arg);
2898                 break;
2899         case FSACTL_DELETE_DISK:
2900         case FSACTL_LNX_DELETE_DISK:
2901                 /*
2902                  * We don't trust the underland to tell us when to delete a
2903                  * container, rather we rely on an AIF coming from the
2904                  * controller
2905                  */
2906                 error = 0;
2907                 break;
2908         case FSACTL_GET_PCI_INFO:
2909                 arg = *(caddr_t*)arg;
2910         case FSACTL_LNX_GET_PCI_INFO:
2911                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_PCI_INFO");
2912                 error = aac_get_pci_info(sc, arg);
2913                 break;
2914         case FSACTL_GET_FEATURES:
2915                 arg = *(caddr_t*)arg;
2916         case FSACTL_LNX_GET_FEATURES:
2917                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "FSACTL_GET_FEATURES");
2918                 error = aac_supported_features(sc, arg);
2919                 break;
2920         default:
2921                 fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "unsupported cmd 0x%lx\n", cmd);
2922                 error = EINVAL;
2923                 break;
2924         }
2925         return(error);
2926 }
2927
2928 static struct filterops aac_filterops =
2929         { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, aac_filter_detach, aac_filter_read };
2930
2931 static int
2932 aac_kqfilter(struct dev_kqfilter_args *ap)
2933 {
2934         cdev_t dev = ap->a_head.a_dev;
2935         struct aac_softc *sc = dev->si_drv1;
2936         struct knote *kn = ap->a_kn;
2937         struct klist *klist;
2938
2939         ap->a_result = 0;
2940
2941         switch (kn->kn_filter) {
2942         case EVFILT_READ:
2943                 kn->kn_fop = &aac_filterops;
2944                 kn->kn_hook = (caddr_t)sc;
2945                 break;
2946         default:
2947                 ap->a_result = EOPNOTSUPP;
2948                 return (0);
2949         }
2950
2951         klist = &sc->rcv_kq.ki_note;
2952         knote_insert(klist, kn);
2953
2954         return (0);
2955 }
2956
2957 static void
2958 aac_filter_detach(struct knote *kn)
2959 {
2960         struct aac_softc *sc = (struct aac_softc *)kn->kn_hook;
2961         struct klist *klist;
2962
2963         klist = &sc->rcv_kq.ki_note;
2964         knote_remove(klist, kn);
2965 }
2966
2967 static int
2968 aac_filter_read(struct knote *kn, long hint)
2969 {
2970         struct aac_softc *sc;
2971         struct aac_fib_context *ctx;
2972
2973         sc = (struct aac_softc *)kn->kn_hook;
2974
2975         lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
2976         for (ctx = sc->fibctx; ctx; ctx = ctx->next)
2977                 if (ctx->ctx_idx != sc->aifq_idx || ctx->ctx_wrap)
2978                         return(1);
2979         lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
2980
2981         return (0);
2982 }
2983
2984 static void
2985 aac_ioctl_event(struct aac_softc *sc, struct aac_event *event, void *arg)
2986 {
2987
2988         switch (event->ev_type) {
2989         case AAC_EVENT_CMFREE:
2990                 KKASSERT(lockstatus(&sc->aac_io_lock, curthread) != 0);
2991                 if (aac_alloc_command(sc, (struct aac_command **)arg)) {
2992                         aac_add_event(sc, event);
2993                         return;
2994                 }
2995                 kfree(event, M_AACBUF);
2996                 wakeup(arg);
2997                 break;
2998         default:
2999                 break;
3000         }
3001 }
3002
3003 /*
3004  * Send a FIB supplied from userspace
3005  */
3006 static int
3007 aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib)
3008 {
3009         struct aac_command *cm;
3010         int size, error;
3011
3012         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3013
3014         cm = NULL;
3015
3016         /*
3017          * Get a command
3018          */
3019         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3020         if (aac_alloc_command(sc, &cm)) {
3021                 struct aac_event *event;
3022
3023                 event = kmalloc(sizeof(struct aac_event), M_AACBUF,
3024                     M_INTWAIT | M_ZERO);
3025                 event->ev_type = AAC_EVENT_CMFREE;
3026                 event->ev_callback = aac_ioctl_event;
3027                 event->ev_arg = &cm;
3028                 aac_add_event(sc, event);
3029                 lksleep(&cm, &sc->aac_io_lock, 0, "sendfib", 0);
3030         }
3031         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3032
3033         /*
3034          * Fetch the FIB header, then re-copy to get data as well.
3035          */
3036         if ((error = copyin(ufib, cm->cm_fib,
3037                             sizeof(struct aac_fib_header))) != 0)
3038                 goto out;
3039         size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header);
3040         if (size > sc->aac_max_fib_size) {
3041                 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %d)\n",
3042                               size, sc->aac_max_fib_size);
3043                 size = sc->aac_max_fib_size;
3044         }
3045         if ((error = copyin(ufib, cm->cm_fib, size)) != 0)
3046                 goto out;
3047         cm->cm_fib->Header.Size = size;
3048         cm->cm_timestamp = time_second;
3049
3050         /*
3051          * Pass the FIB to the controller, wait for it to complete.
3052          */
3053         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3054         error = aac_wait_command(cm);
3055         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3056         if (error != 0) {
3057                 device_printf(sc->aac_dev,
3058                               "aac_wait_command return %d\n", error);
3059                 goto out;
3060         }
3061
3062         /*
3063          * Copy the FIB and data back out to the caller.
3064          */
3065         size = cm->cm_fib->Header.Size;
3066         if (size > sc->aac_max_fib_size) {
3067                 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %d)\n",
3068                               size, sc->aac_max_fib_size);
3069                 size = sc->aac_max_fib_size;
3070         }
3071         error = copyout(cm->cm_fib, ufib, size);
3072
3073 out:
3074         if (cm != NULL) {
3075                 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3076                 aac_release_command(cm);
3077                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3078         }
3079         return(error);
3080 }
3081
3082 /*
3083  * Send a passthrough FIB supplied from userspace
3084  */
3085 static int
3086 aac_ioctl_send_raw_srb(struct aac_softc *sc, caddr_t arg)
3087 {
3088         struct aac_command *cm;
3089         struct aac_event *event;
3090         struct aac_fib *fib;
3091         struct aac_srb *srbcmd, *user_srb;
3092         struct aac_sg_entry *sge;
3093         struct aac_sg_entry64 *sge64;
3094         void *srb_sg_address, *ureply;
3095         uint32_t fibsize, srb_sg_bytecount;
3096         int error, transfer_data;
3097
3098         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3099
3100         cm = NULL;
3101         transfer_data = 0;
3102         fibsize = 0;
3103         user_srb = (struct aac_srb *)arg;
3104
3105         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3106         if (aac_alloc_command(sc, &cm)) {
3107                  event = kmalloc(sizeof(struct aac_event), M_AACBUF,
3108                     M_NOWAIT | M_ZERO);
3109                 if (event == NULL) {
3110                         error = EBUSY;
3111                         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3112                         goto out;
3113                 }
3114                 event->ev_type = AAC_EVENT_CMFREE;
3115                 event->ev_callback = aac_ioctl_event;
3116                 event->ev_arg = &cm;
3117                 aac_add_event(sc, event);
3118                 lksleep(cm, &sc->aac_io_lock, 0, "aacraw", 0);
3119         }
3120         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3121
3122         cm->cm_data = NULL;
3123         fib = cm->cm_fib;
3124         srbcmd = (struct aac_srb *)fib->data;
3125         error = copyin(&user_srb->data_len, &fibsize, sizeof(uint32_t));
3126         if (error != 0)
3127                 goto out;
3128         if (fibsize > (sc->aac_max_fib_size - sizeof(struct aac_fib_header))) {
3129                 error = EINVAL;
3130                 goto out;
3131         }
3132         error = copyin(user_srb, srbcmd, fibsize);
3133         if (error != 0)
3134                 goto out;
3135         srbcmd->function = 0;
3136         srbcmd->retry_limit = 0;
3137         if (srbcmd->sg_map.SgCount > 1) {
3138                 error = EINVAL;
3139                 goto out;
3140         }
3141
3142         /* Retrieve correct SG entries. */
3143         if (fibsize == (sizeof(struct aac_srb) +
3144             srbcmd->sg_map.SgCount * sizeof(struct aac_sg_entry))) {
3145                 sge = srbcmd->sg_map.SgEntry;
3146                 sge64 = NULL;
3147                 srb_sg_bytecount = sge->SgByteCount;
3148                 srb_sg_address = (void *)(uintptr_t)sge->SgAddress;
3149         }
3150 #ifdef __amd64__
3151         else if (fibsize == (sizeof(struct aac_srb) +
3152             srbcmd->sg_map.SgCount * sizeof(struct aac_sg_entry64))) {
3153                 sge = NULL;
3154                 sge64 = (struct aac_sg_entry64 *)srbcmd->sg_map.SgEntry;
3155                 srb_sg_bytecount = sge64->SgByteCount;
3156                 srb_sg_address = (void *)sge64->SgAddress;
3157                 if (sge64->SgAddress > 0xffffffffull &&
3158                     (sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
3159                         error = EINVAL;
3160                         goto out;
3161                 }
3162         }
3163 #endif
3164         else {
3165                 error = EINVAL;
3166                 goto out;
3167         }
3168         ureply = (char *)arg + fibsize;
3169         srbcmd->data_len = srb_sg_bytecount;
3170         if (srbcmd->sg_map.SgCount == 1)
3171                 transfer_data = 1;
3172
3173         cm->cm_sgtable = (struct aac_sg_table *)&srbcmd->sg_map;
3174         if (transfer_data) {
3175                 cm->cm_datalen = srb_sg_bytecount;
3176                 cm->cm_data = kmalloc(cm->cm_datalen, M_AACBUF, M_NOWAIT);
3177                 if (cm->cm_data == NULL) {
3178                         error = ENOMEM;
3179                         goto out;
3180                 }
3181                 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_IN)
3182                         cm->cm_flags |= AAC_CMD_DATAIN;
3183                 if (srbcmd->flags & AAC_SRB_FLAGS_DATA_OUT) {
3184                         cm->cm_flags |= AAC_CMD_DATAOUT;
3185                         error = copyin(srb_sg_address, cm->cm_data,
3186                             cm->cm_datalen);
3187                         if (error != 0)
3188                                 goto out;
3189                 }
3190         }
3191
3192         fib->Header.Size = sizeof(struct aac_fib_header) +
3193             sizeof(struct aac_srb);
3194         fib->Header.XferState =
3195             AAC_FIBSTATE_HOSTOWNED   |
3196             AAC_FIBSTATE_INITIALISED |
3197             AAC_FIBSTATE_EMPTY       |
3198             AAC_FIBSTATE_FROMHOST    |
3199             AAC_FIBSTATE_REXPECTED   |
3200             AAC_FIBSTATE_NORM        |
3201             AAC_FIBSTATE_ASYNC       |
3202             AAC_FIBSTATE_FAST_RESPONSE;
3203         fib->Header.Command = (sc->flags & AAC_FLAGS_SG_64BIT) != 0 ?
3204             ScsiPortCommandU64 : ScsiPortCommand;
3205
3206         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3207         aac_wait_command(cm);
3208         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3209
3210         if (transfer_data && (srbcmd->flags & AAC_SRB_FLAGS_DATA_IN) != 0) {
3211                 error = copyout(cm->cm_data, srb_sg_address, cm->cm_datalen);
3212                 if (error != 0)
3213                         goto out;
3214         }
3215         error = copyout(fib->data, ureply, sizeof(struct aac_srb_response));
3216 out:
3217         if (cm != NULL) {
3218                 if (cm->cm_data != NULL)
3219                         kfree(cm->cm_data, M_AACBUF);
3220                 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3221                 aac_release_command(cm);
3222                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3223         }
3224         return(error);
3225 }
3226
3227 static int
3228 aac_close(struct dev_close_args *ap)
3229 {
3230         cdev_t dev = ap->a_head.a_dev;
3231         struct aac_softc *sc;
3232
3233         sc = dev->si_drv1;
3234         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3235         get_mplock();
3236         device_unbusy(sc->aac_dev);
3237         rel_mplock();
3238
3239         return 0;
3240 }
3241
3242 /*
3243  * Handle an AIF sent to us by the controller; queue it for later reference.
3244  * If the queue fills up, then drop the older entries.
3245  */
3246 static void
3247 aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib)
3248 {
3249         struct aac_aif_command *aif;
3250         struct aac_container *co, *co_next;
3251         struct aac_fib_context *ctx;
3252         struct aac_mntinforesp *mir;
3253         int next, current, found;
3254         int count = 0, added = 0, i = 0;
3255         uint32_t channel;
3256
3257         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3258
3259         aif = (struct aac_aif_command*)&fib->data[0];
3260         aac_print_aif(sc, aif);
3261
3262         /* Is it an event that we should care about? */
3263         switch (aif->command) {
3264         case AifCmdEventNotify:
3265                 switch (aif->data.EN.type) {
3266                 case AifEnAddContainer:
3267                 case AifEnDeleteContainer:
3268                         /*
3269                          * A container was added or deleted, but the message
3270                          * doesn't tell us anything else!  Re-enumerate the
3271                          * containers and sort things out.
3272                          */
3273                         aac_alloc_sync_fib(sc, &fib);
3274                         do {
3275                                 /*
3276                                  * Ask the controller for its containers one at
3277                                  * a time.
3278                                  * XXX What if the controller's list changes
3279                                  * midway through this enumaration?
3280                                  * XXX This should be done async.
3281                                  */
3282                                 if ((mir = aac_get_container_info(sc, fib, i)) == NULL)
3283                                         continue;
3284                                 if (i == 0)
3285                                         count = mir->MntRespCount;
3286                                 /*
3287                                  * Check the container against our list.
3288                                  * co->co_found was already set to 0 in a
3289                                  * previous run.
3290                                  */
3291                                 if ((mir->Status == ST_OK) &&
3292                                     (mir->MntTable[0].VolType != CT_NONE)) {
3293                                         found = 0;
3294                                         TAILQ_FOREACH(co,
3295                                                       &sc->aac_container_tqh,
3296                                                       co_link) {
3297                                                 if (co->co_mntobj.ObjectId ==
3298                                                     mir->MntTable[0].ObjectId) {
3299                                                         co->co_found = 1;
3300                                                         found = 1;
3301                                                         break;
3302                                                 }
3303                                         }
3304                                         /*
3305                                          * If the container matched, continue
3306                                          * in the list.
3307                                          */
3308                                         if (found) {
3309                                                 i++;
3310                                                 continue;
3311                                         }
3312
3313                                         /*
3314                                          * This is a new container.  Do all the
3315                                          * appropriate things to set it up.
3316                                          */
3317                                         aac_add_container(sc, mir, 1);
3318                                         added = 1;
3319                                 }
3320                                 i++;
3321                         } while ((i < count) && (i < AAC_MAX_CONTAINERS));
3322                         aac_release_sync_fib(sc);
3323
3324                         /*
3325                          * Go through our list of containers and see which ones
3326                          * were not marked 'found'.  Since the controller didn't
3327                          * list them they must have been deleted.  Do the
3328                          * appropriate steps to destroy the device.  Also reset
3329                          * the co->co_found field.
3330                          */
3331                         co = TAILQ_FIRST(&sc->aac_container_tqh);
3332                         while (co != NULL) {
3333                                 if (co->co_found == 0) {
3334                                         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3335                                         get_mplock();
3336                                         device_delete_child(sc->aac_dev,
3337                                                             co->co_disk);
3338                                         rel_mplock();
3339                                         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3340                                         co_next = TAILQ_NEXT(co, co_link);
3341                                         lockmgr(&sc->aac_container_lock, LK_EXCLUSIVE);
3342                                         TAILQ_REMOVE(&sc->aac_container_tqh, co,
3343                                                      co_link);
3344                                         lockmgr(&sc->aac_container_lock, LK_RELEASE);
3345                                         kfree(co, M_AACBUF);
3346                                         co = co_next;
3347                                 } else {
3348                                         co->co_found = 0;
3349                                         co = TAILQ_NEXT(co, co_link);
3350                                 }
3351                         }
3352
3353                         /* Attach the newly created containers */
3354                         if (added) {
3355                                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3356                                 get_mplock();
3357                                 bus_generic_attach(sc->aac_dev);
3358                                 rel_mplock();
3359                                 lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3360                         }
3361
3362                         break;
3363
3364                 case AifEnEnclosureManagement:
3365                         switch (aif->data.EN.data.EEE.eventType) {
3366                         case AIF_EM_DRIVE_INSERTION:
3367                         case AIF_EM_DRIVE_REMOVAL:
3368                                 channel = aif->data.EN.data.EEE.unitID;
3369                                 if (sc->cam_rescan_cb != NULL)
3370                                         sc->cam_rescan_cb(sc,
3371                                             (channel >> 24) & 0xF,
3372                                             (channel & 0xFFFF));
3373                                 break;
3374                         }
3375                         break;
3376
3377                 case AifEnAddJBOD:
3378                 case AifEnDeleteJBOD:
3379                         channel = aif->data.EN.data.ECE.container;
3380                         if (sc->cam_rescan_cb != NULL)
3381                                 sc->cam_rescan_cb(sc, (channel >> 24) & 0xF,
3382                                     AAC_CAM_TARGET_WILDCARD);
3383                         break;
3384
3385                 default:
3386                         break;
3387                 }
3388
3389         default:
3390                 break;
3391         }
3392
3393         /* Copy the AIF data to the AIF queue for ioctl retrieval */
3394         lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3395         current = sc->aifq_idx;
3396         next = (current + 1) % AAC_AIFQ_LENGTH;
3397         if (next == 0)
3398                 sc->aifq_filled = 1;
3399         bcopy(fib, &sc->aac_aifq[current], sizeof(struct aac_fib));
3400         /* modify AIF contexts */
3401         if (sc->aifq_filled) {
3402                 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3403                         if (next == ctx->ctx_idx)
3404                                 ctx->ctx_wrap = 1;
3405                         else if (current == ctx->ctx_idx && ctx->ctx_wrap)
3406                                 ctx->ctx_idx = next;
3407                 }
3408         }
3409         sc->aifq_idx = next;
3410         /* On the off chance that someone is sleeping for an aif... */
3411         if (sc->aac_state & AAC_STATE_AIF_SLEEPER)
3412                 wakeup(sc->aac_aifq);
3413         /* token may have been lost */
3414         /* Wakeup any poll()ers */
3415         KNOTE(&sc->rcv_kq.ki_note, 0);
3416         /* token may have been lost */
3417         lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3418
3419         return;
3420 }
3421
3422 /*
3423  * Return the Revision of the driver to userspace and check to see if the
3424  * userspace app is possibly compatible.  This is extremely bogus since
3425  * our driver doesn't follow Adaptec's versioning system.  Cheat by just
3426  * returning what the card reported.
3427  */
3428 static int
3429 aac_rev_check(struct aac_softc *sc, caddr_t udata)
3430 {
3431         struct aac_rev_check rev_check;
3432         struct aac_rev_check_resp rev_check_resp;
3433         int error = 0;
3434
3435         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3436
3437         /*
3438          * Copyin the revision struct from userspace
3439          */
3440         if ((error = copyin(udata, (caddr_t)&rev_check,
3441                         sizeof(struct aac_rev_check))) != 0) {
3442                 return error;
3443         }
3444
3445         fwprintf(sc, HBA_FLAGS_DBG_IOCTL_COMMANDS_B, "Userland revision= %d\n",
3446               rev_check.callingRevision.buildNumber);
3447
3448         /*
3449          * Doctor up the response struct.
3450          */
3451         rev_check_resp.possiblyCompatible = 1;
3452         rev_check_resp.adapterSWRevision.external.comp.major =
3453             AAC_DRIVER_MAJOR_VERSION;
3454         rev_check_resp.adapterSWRevision.external.comp.minor =
3455             AAC_DRIVER_MINOR_VERSION;
3456         rev_check_resp.adapterSWRevision.external.comp.type =
3457             AAC_DRIVER_TYPE;
3458         rev_check_resp.adapterSWRevision.external.comp.dash =
3459             AAC_DRIVER_BUGFIX_LEVEL;
3460         rev_check_resp.adapterSWRevision.buildNumber =
3461             AAC_DRIVER_BUILD;
3462
3463         return(copyout((caddr_t)&rev_check_resp, udata,
3464                         sizeof(struct aac_rev_check_resp)));
3465 }
3466
3467 /*
3468  * Pass the fib context to the caller
3469  */
3470 static int
3471 aac_open_aif(struct aac_softc *sc, caddr_t arg)
3472 {
3473         struct aac_fib_context *fibctx, *ctx;
3474         int error = 0;
3475
3476         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3477
3478         fibctx = kmalloc(sizeof(struct aac_fib_context), M_AACBUF, M_NOWAIT|M_ZERO);
3479         if (fibctx == NULL)
3480                 return (ENOMEM);
3481
3482         lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3483         /* all elements are already 0, add to queue */
3484         if (sc->fibctx == NULL)
3485                 sc->fibctx = fibctx;
3486         else {
3487                 for (ctx = sc->fibctx; ctx->next; ctx = ctx->next)
3488                         ;
3489                 ctx->next = fibctx;
3490                 fibctx->prev = ctx;
3491         }
3492
3493         /* evaluate unique value */
3494         fibctx->unique = (*(u_int32_t *)&fibctx & 0xffffffff);
3495         ctx = sc->fibctx;
3496         while (ctx != fibctx) {
3497                 if (ctx->unique == fibctx->unique) {
3498                         fibctx->unique++;
3499                         ctx = sc->fibctx;
3500                 } else {
3501                         ctx = ctx->next;
3502                 }
3503         }
3504         lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3505
3506         error = copyout(&fibctx->unique, (void *)arg, sizeof(u_int32_t));
3507         if (error)
3508                 aac_close_aif(sc, (caddr_t)ctx);
3509         return error;
3510 }
3511
3512 /*
3513  * Close the caller's fib context
3514  */
3515 static int
3516 aac_close_aif(struct aac_softc *sc, caddr_t arg)
3517 {
3518         struct aac_fib_context *ctx;
3519
3520         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3521
3522         lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3523         for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3524                 if (ctx->unique == *(uint32_t *)&arg) {
3525                         if (ctx == sc->fibctx)
3526                                 sc->fibctx = NULL;
3527                         else {
3528                                 ctx->prev->next = ctx->next;
3529                                 if (ctx->next)
3530                                         ctx->next->prev = ctx->prev;
3531                         }
3532                         break;
3533                 }
3534         }
3535         lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3536         if (ctx)
3537                 kfree(ctx, M_AACBUF);
3538
3539         return 0;
3540 }
3541
3542 /*
3543  * Pass the caller the next AIF in their queue
3544  */
3545 static int
3546 aac_getnext_aif(struct aac_softc *sc, caddr_t arg)
3547 {
3548         struct get_adapter_fib_ioctl agf;
3549         struct aac_fib_context *ctx;
3550         int error;
3551
3552         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3553
3554         if ((error = copyin(arg, &agf, sizeof(agf))) == 0) {
3555                 for (ctx = sc->fibctx; ctx; ctx = ctx->next) {
3556                         if (agf.AdapterFibContext == ctx->unique)
3557                                 break;
3558                 }
3559                 if (!ctx)
3560                         return (EFAULT);
3561
3562                 error = aac_return_aif(sc, ctx, agf.AifFib);
3563                 if (error == EAGAIN && agf.Wait) {
3564                         fwprintf(sc, HBA_FLAGS_DBG_AIF_B, "aac_getnext_aif(): waiting for AIF");
3565                         sc->aac_state |= AAC_STATE_AIF_SLEEPER;
3566                         while (error == EAGAIN) {
3567                                 error = tsleep(sc->aac_aifq,
3568                                                PCATCH, "aacaif", 0);
3569                                 if (error == 0)
3570                                         error = aac_return_aif(sc, ctx, agf.AifFib);
3571                         }
3572                         sc->aac_state &= ~AAC_STATE_AIF_SLEEPER;
3573                 }
3574         }
3575         return(error);
3576 }
3577
3578 /*
3579  * Hand the next AIF off the top of the queue out to userspace.
3580  */
3581 static int
3582 aac_return_aif(struct aac_softc *sc, struct aac_fib_context *ctx, caddr_t uptr)
3583 {
3584         int current, error;
3585
3586         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3587
3588         lockmgr(&sc->aac_aifq_lock, LK_EXCLUSIVE);
3589         current = ctx->ctx_idx;
3590         if (current == sc->aifq_idx && !ctx->ctx_wrap) {
3591                 /* empty */
3592                 lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3593                 return (EAGAIN);
3594         }
3595         error =
3596                 copyout(&sc->aac_aifq[current], (void *)uptr, sizeof(struct aac_fib));
3597         if (error)
3598                 device_printf(sc->aac_dev,
3599                     "aac_return_aif: copyout returned %d\n", error);
3600         else {
3601                 ctx->ctx_wrap = 0;
3602                 ctx->ctx_idx = (current + 1) % AAC_AIFQ_LENGTH;
3603         }
3604         lockmgr(&sc->aac_aifq_lock, LK_RELEASE);
3605         return(error);
3606 }
3607
3608 static int
3609 aac_get_pci_info(struct aac_softc *sc, caddr_t uptr)
3610 {
3611         struct aac_pci_info {
3612                 u_int32_t bus;
3613                 u_int32_t slot;
3614         } pciinf;
3615         int error;
3616
3617         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3618
3619         pciinf.bus = pci_get_bus(sc->aac_dev);
3620         pciinf.slot = pci_get_slot(sc->aac_dev);
3621
3622         error = copyout((caddr_t)&pciinf, uptr,
3623                         sizeof(struct aac_pci_info));
3624
3625         return (error);
3626 }
3627
3628 static int
3629 aac_supported_features(struct aac_softc *sc, caddr_t uptr)
3630 {
3631         struct aac_features f;
3632         int error;
3633
3634         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3635
3636         if ((error = copyin(uptr, &f, sizeof (f))) != 0)
3637                 return (error);
3638
3639         /*
3640          * When the management driver receives FSACTL_GET_FEATURES ioctl with
3641          * ALL zero in the featuresState, the driver will return the current
3642          * state of all the supported features, the data field will not be
3643          * valid.
3644          * When the management driver receives FSACTL_GET_FEATURES ioctl with
3645          * a specific bit set in the featuresState, the driver will return the
3646          * current state of this specific feature and whatever data that are
3647          * associated with the feature in the data field or perform whatever
3648          * action needed indicates in the data field.
3649          */
3650         if (f.feat.fValue == 0) {
3651                 f.feat.fBits.largeLBA =
3652                     (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3653                 /* TODO: In the future, add other features state here as well */
3654         } else {
3655                 if (f.feat.fBits.largeLBA)
3656                         f.feat.fBits.largeLBA =
3657                             (sc->flags & AAC_FLAGS_LBA_64BIT) ? 1 : 0;
3658                 /* TODO: Add other features state and data in the future */
3659         }
3660
3661         error = copyout(&f, uptr, sizeof (f));
3662         return (error);
3663 }
3664
3665 /*
3666  * Give the userland some information about the container.  The AAC arch
3667  * expects the driver to be a SCSI passthrough type driver, so it expects
3668  * the containers to have b:t:l numbers.  Fake it.
3669  */
3670 static int
3671 aac_query_disk(struct aac_softc *sc, caddr_t uptr)
3672 {
3673         struct aac_query_disk query_disk;
3674         struct aac_container *co;
3675         struct aac_disk *disk;
3676         int error, id;
3677
3678         fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
3679
3680         disk = NULL;
3681
3682         error = copyin(uptr, (caddr_t)&query_disk,
3683                        sizeof(struct aac_query_disk));
3684         if (error)
3685                 return (error);
3686
3687         id = query_disk.ContainerNumber;
3688         if (id == -1)
3689                 return (EINVAL);
3690
3691         lockmgr(&sc->aac_container_lock, LK_EXCLUSIVE);
3692         TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) {
3693                 if (co->co_mntobj.ObjectId == id)
3694                         break;
3695                 }
3696
3697         if (co == NULL) {
3698                         query_disk.Valid = 0;
3699                         query_disk.Locked = 0;
3700                         query_disk.Deleted = 1;         /* XXX is this right? */
3701         } else {
3702                 disk = device_get_softc(co->co_disk);
3703                 query_disk.Valid = 1;
3704                 query_disk.Locked =
3705                     (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0;
3706                 query_disk.Deleted = 0;
3707                 query_disk.Bus = device_get_unit(sc->aac_dev);
3708                 query_disk.Target = disk->unit;
3709                 query_disk.Lun = 0;
3710                 query_disk.UnMapped = 0;
3711                 bcopy(disk->ad_dev_t->si_name,
3712                       &query_disk.diskDeviceName[0], 10);
3713         }
3714         lockmgr(&sc->aac_container_lock, LK_RELEASE);
3715
3716         error = copyout((caddr_t)&query_disk, uptr,
3717                         sizeof(struct aac_query_disk));
3718
3719         return (error);
3720 }
3721
3722 static void
3723 aac_get_bus_info(struct aac_softc *sc)
3724 {
3725         struct aac_fib *fib;
3726         struct aac_ctcfg *c_cmd;
3727         struct aac_ctcfg_resp *c_resp;
3728         struct aac_vmioctl *vmi;
3729         struct aac_vmi_businf_resp *vmi_resp;
3730         struct aac_getbusinf businfo;
3731         struct aac_sim *caminf;
3732         device_t child;
3733         int i, found, error;
3734
3735         lockmgr(&sc->aac_io_lock, LK_EXCLUSIVE);
3736         aac_alloc_sync_fib(sc, &fib);
3737         c_cmd = (struct aac_ctcfg *)&fib->data[0];
3738         bzero(c_cmd, sizeof(struct aac_ctcfg));
3739
3740         c_cmd->Command = VM_ContainerConfig;
3741         c_cmd->cmd = CT_GET_SCSI_METHOD;
3742         c_cmd->param = 0;
3743
3744         error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3745             sizeof(struct aac_ctcfg));
3746         if (error) {
3747                 device_printf(sc->aac_dev, "Error %d sending "
3748                     "VM_ContainerConfig command\n", error);
3749                 aac_release_sync_fib(sc);
3750                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3751                 return;
3752         }
3753
3754         c_resp = (struct aac_ctcfg_resp *)&fib->data[0];
3755         if (c_resp->Status != ST_OK) {
3756                 device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n",
3757                     c_resp->Status);
3758                 aac_release_sync_fib(sc);
3759                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3760                 return;
3761         }
3762
3763         sc->scsi_method_id = c_resp->param;
3764
3765         vmi = (struct aac_vmioctl *)&fib->data[0];
3766         bzero(vmi, sizeof(struct aac_vmioctl));
3767
3768         vmi->Command = VM_Ioctl;
3769         vmi->ObjType = FT_DRIVE;
3770         vmi->MethId = sc->scsi_method_id;
3771         vmi->ObjId = 0;
3772         vmi->IoctlCmd = GetBusInfo;
3773
3774         error = aac_sync_fib(sc, ContainerCommand, 0, fib,
3775             sizeof(struct aac_vmi_businf_resp));
3776         if (error) {
3777                 device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n",
3778                     error);
3779                 aac_release_sync_fib(sc);
3780                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3781                 return;
3782         }
3783
3784         vmi_resp = (struct aac_vmi_businf_resp *)&fib->data[0];
3785         if (vmi_resp->Status != ST_OK) {
3786                 device_printf(sc->aac_dev, "VM_Ioctl returned %d\n",
3787                     vmi_resp->Status);
3788                 aac_release_sync_fib(sc);
3789                 lockmgr(&sc->aac_io_lock, LK_RELEASE);
3790                 return;
3791         }
3792
3793         bcopy(&vmi_resp->BusInf, &businfo, sizeof(struct aac_getbusinf));
3794         aac_release_sync_fib(sc);
3795         lockmgr(&sc->aac_io_lock, LK_RELEASE);
3796
3797         found = 0;
3798         for (i = 0; i < businfo.BusCount; i++) {
3799                 if (businfo.BusValid[i] != AAC_BUS_VALID)
3800                         continue;
3801
3802                 caminf = (struct aac_sim *)kmalloc(sizeof(struct aac_sim),
3803                     M_AACBUF, M_INTWAIT | M_ZERO);
3804
3805                 child = device_add_child(sc->aac_dev, "aacp", -1);
3806                 if (child == NULL) {
3807                         device_printf(sc->aac_dev,
3808                             "device_add_child failed for passthrough bus %d\n",
3809                             i);
3810                         kfree(caminf, M_AACBUF);
3811                         break;
3812                 }
3813
3814                 caminf->TargetsPerBus = businfo.TargetsPerBus;
3815                 caminf->BusNumber = i;
3816                 caminf->InitiatorBusId = businfo.InitiatorBusId[i];
3817                 caminf->aac_sc = sc;
3818                 caminf->sim_dev = child;
3819
3820                 device_set_ivars(child, caminf);
3821                 device_set_desc(child, "SCSI Passthrough Bus");
3822                 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link);
3823
3824                 found = 1;
3825         }
3826
3827         if (found)
3828                 bus_generic_attach(sc->aac_dev);
3829
3830         return;
3831 }