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