sys/dev/raid/aac/aac.c

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