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