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