sys/dev/aac/aac.c

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