sys/dev/raid/aac/aac.c

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