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