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