diff options
| -rw-r--r-- | sys/amd64/conf/GENERIC | 1 | ||||
| -rw-r--r-- | sys/conf/NOTES | 5 | ||||
| -rw-r--r-- | sys/conf/files | 1 | ||||
| -rw-r--r-- | sys/dev/aac/aac.c | 1896 | ||||
| -rw-r--r-- | sys/dev/aac/aac_compat.h | 64 | ||||
| -rw-r--r-- | sys/dev/aac/aac_debug.c | 426 | ||||
| -rw-r--r-- | sys/dev/aac/aac_disk.c | 296 | ||||
| -rw-r--r-- | sys/dev/aac/aac_ioctl.h | 78 | ||||
| -rw-r--r-- | sys/dev/aac/aac_pci.c | 272 | ||||
| -rw-r--r-- | sys/dev/aac/aac_tables.h | 117 | ||||
| -rw-r--r-- | sys/dev/aac/aacreg.h | 1082 | ||||
| -rw-r--r-- | sys/dev/aac/aacvar.h | 451 | ||||
| -rw-r--r-- | sys/i386/conf/GENERIC | 1 | ||||
| -rw-r--r-- | sys/i386/conf/NOTES | 5 | ||||
| -rw-r--r-- | sys/modules/Makefile | 2 | ||||
| -rw-r--r-- | sys/modules/aac/Makefile | 13 | ||||
| -rw-r--r-- | sys/sys/aac_ioctl.h | 78 |
17 files changed, 4787 insertions, 1 deletions
diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC index 215ee664bbac..7cc95b221d20 100644 --- a/sys/amd64/conf/GENERIC +++ b/sys/amd64/conf/GENERIC @@ -112,6 +112,7 @@ device cd # CD device pass # Passthrough device (direct SCSI access) # RAID controllers +device aac # Adaptec FSA RAID device ida # Compaq Smart RAID device amr # AMI MegaRAID device mlx # Mylex DAC960 family diff --git a/sys/conf/NOTES b/sys/conf/NOTES index 2ebc8c70d044..8e690c1a87d4 100644 --- a/sys/conf/NOTES +++ b/sys/conf/NOTES @@ -1331,6 +1331,11 @@ options DPT_ALLOW_MEMIO device mly # +# Adaptec FSA RAID controllers, including integrated DELL controllers, +# the Dell PERC 2/QC and the HP NetRAID-4M +device aac + +# # Compaq Smart RAID, Mylex DAC960 and AMI MegaRAID controllers. Only # one entry is needed; the code will find and configure all supported # controllers. diff --git a/sys/conf/files b/sys/conf/files index 7b9c720cd3d0..9020533f4f93 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -71,6 +71,7 @@ ddb/db_trap.c optional ddb ddb/db_variables.c optional ddb ddb/db_watch.c optional ddb ddb/db_write_cmd.c optional ddb +dev/aac/aac.c optional aac dev/acpi/acpi.c count acpi dev/acpi/acpi_powerres.c optional acpi dev/acpi/aml/aml_amlmem.c optional acpi diff --git a/sys/dev/aac/aac.c b/sys/dev/aac/aac.c new file mode 100644 index 000000000000..0d91554e2336 --- /dev/null +++ b/sys/dev/aac/aac.c @@ -0,0 +1,1896 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/malloc.h> +#include <sys/kernel.h> + +#include <dev/aac/aac_compat.h> + +#include <sys/bus.h> +#include <sys/conf.h> +#include <sys/devicestat.h> +#include <sys/disk.h> +#include <sys/file.h> +#include <sys/signalvar.h> + +#include <machine/bus_memio.h> +#include <machine/bus.h> +#include <machine/clock.h> +#include <machine/resource.h> + +#include <dev/aac/aacreg.h> +#include <dev/aac/aacvar.h> +#include <dev/aac/aac_tables.h> +#include <dev/aac/aac_ioctl.h> + +devclass_t aac_devclass; + +static void aac_startup(void *arg); + +/* Command Processing */ +static void aac_startio(struct aac_softc *sc); +static int aac_start(struct aac_command *cm); +static void aac_complete(void *context, int pending); +static int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp); +static void aac_bio_complete(struct aac_command *cm); +static int aac_wait_command(struct aac_command *cm, int timeout); +static void aac_host_command(struct aac_softc *sc); +static void aac_host_response(struct aac_softc *sc); + +/* Command Buffer Management */ +static int aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp); +static void aac_release_command(struct aac_command *cm); +static void aac_map_command_cluster(void *arg, bus_dma_segment_t *segs, int nseg, int error); +static void aac_alloc_command_cluster(struct aac_softc *sc); +static void aac_free_command_cluster(struct aac_command_cluster *cmc); +static void aac_map_command(struct aac_command *cm); +static void aac_unmap_command(struct aac_command *cm); + +/* Hardware Interface */ +static void aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error); +static int aac_init(struct aac_softc *sc); +static int aac_sync_command(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3, + u_int32_t *sp); +static int aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate, + void *data, u_int16_t datasize, + void *result, u_int16_t *resultsize); +static int aac_enqueue_fib(struct aac_softc *sc, int queue, u_int32_t fib_size, u_int32_t fib_addr); +static int aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size, struct aac_fib **fib_addr); + +/* StrongARM interface */ +static int aac_sa_get_fwstatus(struct aac_softc *sc); +static void aac_sa_qnotify(struct aac_softc *sc, int qbit); +static int aac_sa_get_istatus(struct aac_softc *sc); +static void aac_sa_clear_istatus(struct aac_softc *sc, int mask); +static void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3); +static int aac_sa_get_mailboxstatus(struct aac_softc *sc); +static void aac_sa_set_interrupts(struct aac_softc *sc, int enable); + +struct aac_interface aac_sa_interface = { + aac_sa_get_fwstatus, + aac_sa_qnotify, + aac_sa_get_istatus, + aac_sa_clear_istatus, + aac_sa_set_mailbox, + aac_sa_get_mailboxstatus, + aac_sa_set_interrupts +}; + +/* i960Rx interface */ +static int aac_rx_get_fwstatus(struct aac_softc *sc); +static void aac_rx_qnotify(struct aac_softc *sc, int qbit); +static int aac_rx_get_istatus(struct aac_softc *sc); +static void aac_rx_clear_istatus(struct aac_softc *sc, int mask); +static void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3); +static int aac_rx_get_mailboxstatus(struct aac_softc *sc); +static void aac_rx_set_interrupts(struct aac_softc *sc, int enable); + +struct aac_interface aac_rx_interface = { + aac_rx_get_fwstatus, + aac_rx_qnotify, + aac_rx_get_istatus, + aac_rx_clear_istatus, + aac_rx_set_mailbox, + aac_rx_get_mailboxstatus, + aac_rx_set_interrupts +}; + +/* Debugging and Diagnostics */ +static void aac_describe_controller(struct aac_softc *sc); +static char *aac_describe_code(struct aac_code_lookup *table, u_int32_t code); + +/* Management Interface */ +static d_open_t aac_open; +static d_close_t aac_close; +static d_ioctl_t aac_ioctl; +static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib); +static void aac_handle_aif(struct aac_softc *sc, struct aac_aif_command *aif); +static int aac_return_aif(struct aac_softc *sc, caddr_t uptr); +#ifdef AAC_COMPAT_LINUX +static int aac_linux_rev_check(struct aac_softc *sc, caddr_t udata); +static int aac_linux_getnext_aif(struct aac_softc *sc, caddr_t arg); +#endif + +#define AAC_CDEV_MAJOR 150 + +static struct cdevsw aac_cdevsw = { + aac_open, /* open */ + aac_close, /* close */ + noread, /* read */ + nowrite, /* write */ + aac_ioctl, /* ioctl */ + nopoll, /* poll */ + nommap, /* mmap */ + nostrategy, /* strategy */ + "aac", /* name */ + AAC_CDEV_MAJOR, /* major */ + nodump, /* dump */ + nopsize, /* psize */ + 0, /* flags */ + -1, /* bmaj */ +}; + +/******************************************************************************** + ******************************************************************************** + Device Interface + ******************************************************************************** + ********************************************************************************/ + +/******************************************************************************** + * Initialise the controller and softc + */ +int +aac_attach(struct aac_softc *sc) +{ + int error, unit; + + debug_called(1); + + /* + * Initialise per-controller queues. + */ + TAILQ_INIT(&sc->aac_freecmds); + TAILQ_INIT(&sc->aac_ready); + TAILQ_INIT(&sc->aac_completed); + TAILQ_INIT(&sc->aac_clusters); + bioq_init(&sc->aac_bioq); + +#if __FreeBSD_version >= 500005 + /* + * Initialise command-completion task. + */ + TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc); +#endif + + /* disable interrupts before we enable anything */ + AAC_MASK_INTERRUPTS(sc); + + /* mark controller as suspended until we get ourselves organised */ + sc->aac_state |= AAC_STATE_SUSPEND; + + /* + * Initialise the adapter. + */ + if ((error = aac_init(sc))) + return(error); + + /* + * Print a little information about the controller. + */ + aac_describe_controller(sc); + + /* + * Register to probe our containers later. + */ + bzero(&sc->aac_ich, sizeof(struct intr_config_hook)); + sc->aac_ich.ich_func = aac_startup; + sc->aac_ich.ich_arg = sc; + if (config_intrhook_establish(&sc->aac_ich) != 0) { + device_printf(sc->aac_dev, "can't establish configuration hook\n"); + return(ENXIO); + } + + /* + * Make the control device. + */ + unit = device_get_unit(sc->aac_dev); + sc->aac_dev_t = make_dev(&aac_cdevsw, unit, UID_ROOT, GID_WHEEL, 0644, "aac%d", unit); + sc->aac_dev_t->si_drv1 = sc; + + return(0); +} + +/******************************************************************************** + * Probe for containers, create disks. + */ +static void +aac_startup(void *arg) +{ + struct aac_softc *sc = (struct aac_softc *)arg; + struct aac_mntinfo mi; + struct aac_mntinforesponse mir; + device_t child; + u_int16_t rsize; + int i; + + debug_called(1); + + /* disconnect ourselves from the intrhook chain */ + config_intrhook_disestablish(&sc->aac_ich); + + /* loop over possible containers */ + mi.Command = VM_NameServe; + mi.MntType = FT_FILESYS; + for (i = 0; i < AAC_MAX_CONTAINERS; i++) { + /* request information on this container */ + mi.MntCount = i; + if (aac_sync_fib(sc, ContainerCommand, 0, &mi, sizeof(struct aac_mntinfo), &mir, &rsize)) { + debug(2, "error probing container %d", i); + continue; + } + /* check response size */ + if (rsize != sizeof(mir)) { + debug(2, "container info response wrong size (%d should be %d)", rsize, sizeof(*mir)); + continue; + } + /* + * Check container volume type for validity. Note that many of the possible types + * may never show up. + */ + if ((mir.Status == ST_OK) && (mir.MntTable[0].VolType != CT_NONE)) { + debug(1, "%d: id %x name '%.16s' size %u type %d", + i, mir.MntTable[0].ObjectId, + mir.MntTable[0].FileSystemName, mir.MntTable[0].Capacity, + mir.MntTable[0].VolType); + + if ((child = device_add_child(sc->aac_dev, NULL, -1)) == NULL) { + device_printf(sc->aac_dev, "device_add_child failed\n"); + } else { + device_set_ivars(child, &sc->aac_container[i]); + } + device_set_desc(child, aac_describe_code(aac_container_types, mir.MntTable[0].VolType)); + sc->aac_container[i].co_disk = child; + sc->aac_container[i].co_mntobj = mir.MntTable[0]; + } + } + + /* poke the bus to actually attach the child devices */ + if (bus_generic_attach(sc->aac_dev)) + device_printf(sc->aac_dev, "bus_generic_attach failed\n"); + + /* mark the controller up */ + sc->aac_state &= ~AAC_STATE_SUSPEND; + + /* enable interrupts now */ + AAC_UNMASK_INTERRUPTS(sc); +} + +/******************************************************************************** + * Free all of the resources associated with (sc) + * + * Should not be called if the controller is active. + * + * XXX verify that we are freeing all our resources here... + */ +void +aac_free(struct aac_softc *sc) +{ + struct aac_command_cluster *cmc; + + debug_called(1); + + /* remove the control device */ + if (sc->aac_dev_t != NULL) + destroy_dev(sc->aac_dev_t); + + /* throw away any command buffers */ + while ((cmc = aac_dequeue_cluster(sc)) != NULL) + aac_free_command_cluster(cmc); + + /* destroy the common area */ + if (sc->aac_common) { + bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap); + bus_dmamem_free(sc->aac_common_dmat, sc->aac_common, sc->aac_common_dmamap); + bus_dma_tag_destroy(sc->aac_common_dmat); + } + + /* disconnect the interrupt handler */ + if (sc->aac_intr) + bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr); + if (sc->aac_irq != NULL) + bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid, sc->aac_irq); + + /* destroy data-transfer DMA tag */ + if (sc->aac_buffer_dmat) + bus_dma_tag_destroy(sc->aac_buffer_dmat); + + /* destroy FIB DMA tag */ + if (sc->aac_buffer_dmat) + bus_dma_tag_destroy(sc->aac_fib_dmat); + + /* destroy the parent DMA tag */ + if (sc->aac_parent_dmat) + bus_dma_tag_destroy(sc->aac_parent_dmat); + + /* release the register window mapping */ + if (sc->aac_regs_resource != NULL) + bus_release_resource(sc->aac_dev, SYS_RES_MEMORY, sc->aac_regs_rid, sc->aac_regs_resource); +} + +/******************************************************************************** + * Disconnect from the controller completely, in preparation for unload. + */ +int +aac_detach(device_t dev) +{ + struct aac_softc *sc = device_get_softc(dev); + int error; + + debug_called(1); + + if (sc->aac_state & AAC_STATE_OPEN) + return(EBUSY); + + if ((error = aac_shutdown(dev))) + return(error); + + aac_free(sc); + + return(0); +} + +/******************************************************************************** + * Bring the controller down to a dormant state and detach all child devices. + * + * This function is called before detach or system shutdown. + * + * Note that we can assume that the camq on the controller is empty, as we won't + * allow shutdown if any device is open. + */ +int +aac_shutdown(device_t dev) +{ + struct aac_softc *sc = device_get_softc(dev); + struct aac_close_command cc; + int s, i; + + debug_called(1); + + s = splbio(); + + sc->aac_state |= AAC_STATE_SUSPEND; + + /* + * Send a Container shutdown followed by a HostShutdown FIB to the + * controller to convince it that we don't want to talk to it anymore. + * We've been closed and all I/O completed already + */ + device_printf(sc->aac_dev, "shutting down controller..."); + + cc.Command = VM_CloseAll; + cc.ContainerId = 0xffffffff; + if (aac_sync_fib(sc, ContainerCommand, 0, &cc, sizeof(cc), NULL, NULL)) { + printf("FAILED.\n"); + } else { + i = 0; + if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN, &i, sizeof(i), NULL, NULL)) { + printf("FAILED.\n"); + } else { + printf("done.\n"); + } + } + + AAC_MASK_INTERRUPTS(sc); + + splx(s); + return(0); +} + +/******************************************************************************** + * Bring the controller to a quiescent state, ready for system suspend. + */ +int +aac_suspend(device_t dev) +{ + struct aac_softc *sc = device_get_softc(dev); + int s; + + debug_called(1); + s = splbio(); + + sc->aac_state |= AAC_STATE_SUSPEND; + + AAC_MASK_INTERRUPTS(sc); + splx(s); + return(0); +} + +/******************************************************************************** + * Bring the controller back to a state ready for operation. + */ +int +aac_resume(device_t dev) +{ + struct aac_softc *sc = device_get_softc(dev); + + debug_called(1); + sc->aac_state &= ~AAC_STATE_SUSPEND; + AAC_UNMASK_INTERRUPTS(sc); + return(0); +} + +/******************************************************************************* + * Take an interrupt. + */ +void +aac_intr(void *arg) +{ + struct aac_softc *sc = (struct aac_softc *)arg; + u_int16_t reason; + + debug_called(2); + + reason = AAC_GET_ISTATUS(sc); + + /* controller wants to talk to the log? XXX should we defer this? */ + if (reason & AAC_DB_PRINTF) { + if (sc->aac_common->ac_printf[0]) { + device_printf(sc->aac_dev, "** %.*s", AAC_PRINTF_BUFSIZE, sc->aac_common->ac_printf); + sc->aac_common->ac_printf[0] = 0; + } + AAC_CLEAR_ISTATUS(sc, AAC_DB_PRINTF); + AAC_QNOTIFY(sc, AAC_DB_PRINTF); + } + + /* controller has a message for us? */ + if (reason & AAC_DB_COMMAND_READY) { + aac_host_command(sc); + AAC_CLEAR_ISTATUS(sc, AAC_DB_COMMAND_READY); + } + + /* controller has a response for us? */ + if (reason & AAC_DB_RESPONSE_READY) { + aac_host_response(sc); + AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY); + } + + /* spurious interrupts that we don't use - reset the mask and clear the interrupts */ + if (reason & (AAC_DB_COMMAND_NOT_FULL | AAC_DB_RESPONSE_NOT_FULL)) { + AAC_UNMASK_INTERRUPTS(sc); + AAC_CLEAR_ISTATUS(sc, AAC_DB_COMMAND_NOT_FULL | AAC_DB_RESPONSE_NOT_FULL); + } +}; + +/******************************************************************************** + ******************************************************************************** + Command Processing + ******************************************************************************** + ********************************************************************************/ + +/******************************************************************************** + * Start as much queued I/O as possible on the controller + */ +static void +aac_startio(struct aac_softc *sc) +{ + struct aac_command *cm; + + debug_called(2); + + for(;;) { + /* try to get a command that's been put off for lack of resources */ + cm = aac_dequeue_ready(sc); + + /* try to build a command off the bio queue (ignore error return) */ + aac_bio_command(sc, &cm); + + /* nothing to do? */ + if (cm == NULL) + break; + + /* try to give the command to the controller */ + if (aac_start(cm) == EBUSY) { + /* put it on the ready queue for later */ + aac_requeue_ready(cm); + break; + } + } +} + +/******************************************************************************** + * Deliver a command to the controller; allocate controller resources at the + * last moment when possible. + */ +static int +aac_start(struct aac_command *cm) +{ + struct aac_softc *sc = cm->cm_sc; + + debug_called(2); + + /* get the command mapped */ + aac_map_command(cm); + + /* fix up the address values */ + cm->cm_fib->Header.SenderFibAddress = (u_int32_t)cm->cm_fib; + cm->cm_fib->Header.ReceiverFibAddress = cm->cm_fibphys; + + /* save a pointer to the command for speedy reverse-lookup */ + cm->cm_fib->Header.SenderData = (u_int32_t)cm; /* XXX ack, sizing */ + + /* put the FIB on the outbound queue */ + if (aac_enqueue_fib(sc, AAC_ADAP_NORM_CMD_QUEUE, cm->cm_fib->Header.Size, + cm->cm_fib->Header.ReceiverFibAddress)) + return(EBUSY); + + return(0); +} + +/******************************************************************************** + * Handle notification of one or more FIBs coming from the controller. + */ +static void +aac_host_command(struct aac_softc *sc) +{ + struct aac_fib *fib; + u_int32_t fib_size; + + debug_called(1); + + for (;;) { + if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE, &fib_size, &fib)) + break; /* nothing to do */ + + switch(fib->Header.Command) { + case AifRequest: + aac_handle_aif(sc, (struct aac_aif_command *)&fib->data[0]); + break; + default: + device_printf(sc->aac_dev, "unknown command from controller\n"); + AAC_PRINT_FIB(sc, fib); + break; + } + + /* XXX reply to FIBs requesting responses ?? */ + /* XXX how do we return these FIBs to the controller? */ + } +} + +/******************************************************************************** + * Handle notification of one or more FIBs completed by the controller + */ +static void +aac_host_response(struct aac_softc *sc) +{ + struct aac_command *cm; + struct aac_fib *fib; + u_int32_t fib_size; + + debug_called(2); + + for (;;) { + /* look for completed FIBs on our queue */ + if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size, &fib)) + break; /* nothing to do */ + + /* get the command, unmap and queue for later processing */ + cm = (struct aac_command *)fib->Header.SenderData; + if (cm == NULL) { + AAC_PRINT_FIB(sc, fib); + } else { + aac_unmap_command(cm); /* XXX defer? */ + aac_enqueue_completed(cm); + } + } + + /* handle completion processing */ +#if __FreeBSD_version >= 500005 + taskqueue_enqueue(taskqueue_swi, &sc->aac_task_complete); +#else + aac_complete(sc, 0); +#endif +} + +/******************************************************************************** + * Process completed commands. + */ +static void +aac_complete(void *context, int pending) +{ + struct aac_softc *sc = (struct aac_softc *)context; + struct aac_command *cm; + + debug_called(2); + + /* pull completed commands off the queue */ + for (;;) { + cm = aac_dequeue_completed(sc); + if (cm == NULL) + return; + cm->cm_flags |= AAC_CMD_COMPLETED; + + /* is there a completion handler? */ + if (cm->cm_complete != NULL) { + cm->cm_complete(cm); + } else { + /* assume that someone is sleeping on this command */ + wakeup(cm); + } + } +} + +/******************************************************************************** + * Handle a bio submitted from a disk device. + */ +void +aac_submit_bio(struct bio *bp) +{ + struct aac_disk *ad = (struct aac_disk *)bp->bio_dev->si_drv1; + struct aac_softc *sc = ad->ad_controller; + + debug_called(2); + + /* queue the BIO and try to get some work done */ + bioq_insert_tail(&sc->aac_bioq, bp); + aac_startio(sc); +} + +/******************************************************************************** + * Get a bio and build a command to go with it. + */ +static int +aac_bio_command(struct aac_softc *sc, struct aac_command **cmp) +{ + struct aac_command *cm; + struct aac_fib *fib; + struct aac_blockread *br; + struct aac_blockwrite *bw; + struct aac_disk *ad; + struct bio *bp; + int s; + + debug_called(2); + + /* get the resources we will need */ + cm = NULL; + s = splbio(); + if ((bp = bioq_first(&sc->aac_bioq))) + bioq_remove(&sc->aac_bioq, bp); + splx(s); + if (bp == NULL) /* no work? */ + goto fail; + if (aac_alloc_command(sc, &cm)) /* get a command */ + goto fail; + + /* fill out the command */ + cm->cm_private = bp; + + /* build the FIB */ + fib = cm->cm_fib; + fib->Header.XferState = + AAC_FIBSTATE_HOSTOWNED | + AAC_FIBSTATE_INITIALISED | + AAC_FIBSTATE_FROMHOST | + AAC_FIBSTATE_REXPECTED | + AAC_FIBSTATE_NORM; + fib->Header.Command = ContainerCommand; + fib->Header.Size = sizeof(struct aac_fib_header); + + /* build the read/write request */ + ad = (struct aac_disk *)bp->bio_dev->si_drv1; + cm->cm_data = (void *)bp->bio_data; + cm->cm_datalen = bp->bio_bcount; + cm->cm_complete = aac_bio_complete; + if (BIO_IS_READ(bp)) { + br = (struct aac_blockread *)&fib->data[0]; + br->Command = VM_CtBlockRead; + br->ContainerId = ad->ad_container->co_mntobj.ObjectId; + br->BlockNumber = bp->bio_pblkno; + br->ByteCount = bp->bio_bcount; + fib->Header.Size += sizeof(struct aac_blockread); + cm->cm_sgtable = &br->SgMap; + cm->cm_flags |= AAC_CMD_DATAIN; + } else { + bw = (struct aac_blockwrite *)&fib->data[0]; + bw->Command = VM_CtBlockWrite; + bw->ContainerId = ad->ad_container->co_mntobj.ObjectId; + bw->BlockNumber = bp->bio_pblkno; + bw->ByteCount = bp->bio_bcount; + bw->Stable = CUNSTABLE; /* XXX what's appropriate here? */ + fib->Header.Size += sizeof(struct aac_blockwrite); + cm->cm_flags |= AAC_CMD_DATAOUT; + cm->cm_sgtable = &bw->SgMap; + } + + *cmp = cm; + return(0); + +fail: + if (bp != NULL) + bioq_insert_tail(&sc->aac_bioq, bp); + if (cm != NULL) + aac_release_command(cm); + return(ENOMEM); +} + +/******************************************************************************** + * Handle a bio-instigated command that has been completed. + */ +static void +aac_bio_complete(struct aac_command *cm) +{ + struct aac_softc *sc = cm->cm_sc; + struct aac_blockread_response *brr; + struct aac_blockwrite_response *bwr; + struct bio *bp; + AAC_FSAStatus status; + + /* fetch relevant status and then release the command */ + bp = (struct bio *)cm->cm_private; + if (BIO_IS_READ(bp)) { + brr = (struct aac_blockread_response *)&cm->cm_fib->data[0]; + status = brr->Status; + } else { + bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0]; + status = bwr->Status; + } + aac_release_command(cm); + + /* fix up the bio based on status */ + if (status == ST_OK) { + bp->bio_resid = 0; + } else { + bp->bio_error = EIO; + bp->bio_flags |= BIO_ERROR; + + /* XXX be more verbose? */ + device_printf(sc->aac_dev, "I/O error %d (%s)\n", status, AAC_COMMAND_STATUS(status)); + } + aac_complete_bio(bp); /* XXX rename one of these functions! */ +} + +/******************************************************************************** + * Submit a command to the controller, return when it completes. + */ +static int +aac_wait_command(struct aac_command *cm, int timeout) +{ + int s, error = 0; + + debug_called(2); + + /* Put the command on the ready queue and get things going */ + aac_enqueue_ready(cm); + aac_startio(cm->cm_sc); + s = splbio(); + while(!(cm->cm_flags & AAC_CMD_COMPLETED) && (error != EWOULDBLOCK)) { + error = tsleep(cm, PRIBIO, "aacwait", timeout * hz); + } + splx(s); + return(error); +} + +/******************************************************************************** + ******************************************************************************** + Command Buffer Management + ******************************************************************************** + ********************************************************************************/ + +/******************************************************************************** + * Allocate a command. + */ +static int +aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp) +{ + struct aac_command *cm; + + debug_called(3); + + cm = aac_dequeue_free(sc); + if (cm == NULL) { + aac_alloc_command_cluster(sc); + cm = aac_dequeue_free(sc); + } + if (cm == NULL) + return(ENOMEM); + + /* initialise the command/FIB */ + cm->cm_sgtable = NULL; + cm->cm_flags = 0; + cm->cm_complete = NULL; + cm->cm_private = NULL; + cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY; + cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB; + cm->cm_fib->Header.Flags = 0; + cm->cm_fib->Header.SenderSize = sizeof(struct aac_fib); + + /* + * These are duplicated in aac_start to cover the case where an + * intermediate stage may have destroyed them. They're left + * initialised here for debugging purposes only. + */ + cm->cm_fib->Header.SenderFibAddress = (u_int32_t)cm->cm_fib; + cm->cm_fib->Header.ReceiverFibAddress = cm->cm_fibphys; + + *cmp = cm; + return(0); +} + +/******************************************************************************** + * Release a command back to the freelist. + */ +static void +aac_release_command(struct aac_command *cm) +{ + debug_called(3); + + aac_enqueue_free(cm); +} + +/******************************************************************************** + * Map helper for command cluster allocation. Tell each of the FIBs what its + * address in the adapter's space is, fill in a few other fields. + */ +static void +aac_map_command_cluster(void *arg, bus_dma_segment_t *segs, int nseg, int error) +{ + struct aac_command_cluster *cmc = (struct aac_command_cluster *)arg; + + debug_called(3); + + cmc->cmc_fibphys = segs[0].ds_addr; +} + +/******************************************************************************** + * Allocate and initialise a cluster of commands. + */ +static void +aac_alloc_command_cluster(struct aac_softc *sc) +{ + struct aac_command_cluster *cmc; + struct aac_command *cm; + int i; + + debug_called(1); + + cmc = malloc(sizeof(struct aac_command_cluster), M_DEVBUF, M_NOWAIT); + if (cmc != NULL) { + bzero(cmc, sizeof(*cmc)); + + /* allocate the FIB cluster in DMAable memory and load it */ + if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&cmc->cmc_fibs, BUS_DMA_NOWAIT, &cmc->cmc_fibmap)) { + free(cmc, M_DEVBUF); + return; + } + bus_dmamap_load(sc->aac_fib_dmat, cmc->cmc_fibmap, cmc->cmc_fibs, + AAC_CLUSTER_COUNT * sizeof(struct aac_fib), aac_map_command_cluster, cmc, 0); + + aac_enqueue_cluster(sc, cmc); + for (i = 0; i < AAC_CLUSTER_COUNT; i++) { + cm = &cmc->cmc_command[i]; + cm->cm_sc = sc; + cm->cm_fib = cmc->cmc_fibs + i; + cm->cm_fibphys = cmc->cmc_fibphys + (i * sizeof(struct aac_fib)); + + if (!bus_dmamap_create(sc->aac_buffer_dmat, 0, &cm->cm_datamap)) + aac_release_command(cm); + } + } else { + debug(2, "can't allocate memeory for command cluster"); + } +} + +/******************************************************************************** + * Free a command cluster. + */ +static void +aac_free_command_cluster(struct aac_command_cluster *cmc) +{ + struct aac_softc *sc = cmc->cmc_command[0].cm_sc; + int i; + + debug_called(1); + + for (i = 0; i < AAC_CLUSTER_COUNT; i++) + bus_dmamap_destroy(sc->aac_buffer_dmat, cmc->cmc_command[i].cm_datamap); + bus_dmamap_unload(sc->aac_fib_dmat, cmc->cmc_fibmap); + bus_dmamem_free(sc->aac_fib_dmat, cmc->cmc_fibs, cmc->cmc_fibmap); + + free(cmc, M_DEVBUF); +} + +/******************************************************************************** + * Command-mapping helper function - populate this command's s/g table. + */ +static void +aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error) +{ + struct aac_command *cm = (struct aac_command *)arg; + struct aac_fib *fib = cm->cm_fib; + struct aac_sg_table *sg; + int i; + + debug_called(3); + + /* find the s/g table */ + sg = cm->cm_sgtable; + + /* copy into the FIB */ + if (sg != NULL) { + sg->SgCount = nseg; + for (i = 0; i < nseg; i++) { + sg->SgEntry[i].SgAddress = segs[i].ds_addr; + sg->SgEntry[i].SgByteCount = segs[i].ds_len; + } + /* update the FIB size for the s/g count */ + fib->Header.Size += nseg * sizeof(struct aac_sg_entry); + } + +} + +/******************************************************************************** + * Map a command into controller-visible space. + */ +static void +aac_map_command(struct aac_command *cm) +{ + struct aac_softc *sc = cm->cm_sc; + + debug_called(2); + + /* don't map more than once */ + if (cm->cm_flags & AAC_CMD_MAPPED) + return; + + if (cm->cm_datalen != 0) { + bus_dmamap_load(sc->aac_buffer_dmat, cm->cm_datamap, cm->cm_data, + cm->cm_datalen, aac_map_command_sg, cm, 0); + + if (cm->cm_flags & AAC_CMD_DATAIN) + bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, BUS_DMASYNC_PREREAD); + if (cm->cm_flags & AAC_CMD_DATAOUT) + bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, BUS_DMASYNC_PREWRITE); + } + cm->cm_flags |= AAC_CMD_MAPPED; +} + +/******************************************************************************** + * Unmap a command from controller-visible space. + */ +static void +aac_unmap_command(struct aac_command *cm) +{ + struct aac_softc *sc = cm->cm_sc; + + debug_called(2); + + if (!(cm->cm_flags & AAC_CMD_MAPPED)) + return; + + if (cm->cm_datalen != 0) { + if (cm->cm_flags & AAC_CMD_DATAIN) + bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, BUS_DMASYNC_POSTREAD); + if (cm->cm_flags & AAC_CMD_DATAOUT) + bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, BUS_DMASYNC_POSTWRITE); + + bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap); + } + cm->cm_flags &= ~AAC_CMD_MAPPED; +} + +/******************************************************************************** + ******************************************************************************** + Hardware Interface + ******************************************************************************** + ********************************************************************************/ + +/******************************************************************************** + * Initialise the adapter. + */ +static void +aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error) +{ + struct aac_softc *sc = (struct aac_softc *)arg; + + debug_called(1); + + sc->aac_common_busaddr = segs[0].ds_addr; +} + +static int +aac_init(struct aac_softc *sc) +{ + struct aac_adapter_init *ip; + time_t then; + u_int32_t code; + u_int8_t *qaddr; + + debug_called(1); + + /* + * First wait for the adapter to come ready. + */ + then = time_second; + do { + code = AAC_GET_FWSTATUS(sc); + if (code & AAC_SELF_TEST_FAILED) { + device_printf(sc->aac_dev, "FATAL: selftest failed\n"); + return(ENXIO); + } + if (code & AAC_KERNEL_PANIC) { + device_printf(sc->aac_dev, "FATAL: controller kernel panic\n"); + return(ENXIO); + } + if (time_second > (then + AAC_BOOT_TIMEOUT)) { + device_printf(sc->aac_dev, "FATAL: controller not coming ready, status %x\n", code); + return(ENXIO); + } + } while (!(code & AAC_UP_AND_RUNNING)); + + /* + * Create DMA tag for the common structure and allocate it. + */ + if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + sizeof(struct aac_common), 1,/* maxsize, nsegments */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ + 0, /* flags */ + &sc->aac_common_dmat)) { + device_printf(sc->aac_dev, "can't allocate common structure DMA tag\n"); + return(ENOMEM); + } + if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common, BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) { + device_printf(sc->aac_dev, "can't allocate common structure\n"); + return(ENOMEM); + } + bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap, sc->aac_common, sizeof(*sc->aac_common), + aac_common_map, sc, 0); + bzero(sc->aac_common, sizeof(*sc->aac_common)); + + /* + * Fill in the init structure. This tells the adapter about the physical location + * of various important shared data structures. + */ + ip = &sc->aac_common->ac_init; + ip->InitStructRevision = AAC_INIT_STRUCT_REVISION; + + ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr + fldoff(aac_common, ac_fibs); + ip->AdapterFibsVirtualAddress = &sc->aac_common->ac_fibs[0]; + ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib); + ip->AdapterFibAlign = sizeof(struct aac_fib); + + ip->PrintfBufferAddress = sc->aac_common_busaddr + fldoff(aac_common, ac_printf); + ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE; + + ip->HostPhysMemPages = 0; /* not used? */ + ip->HostElapsedSeconds = time_second; /* reset later if invalid */ + + /* + * Initialise FIB queues. Note that it appears that the layout of the indexes + * and the segmentation of the entries is mandated by the adapter, which is + * only told about the base of the queue index fields. + * + * The initial values of the indices are assumed to inform the adapter + * of the sizes of the respective queues. + * + * The Linux driver uses a much more complex scheme whereby several header + * records are kept for each queue. We use a couple of generic list manipulation + * functions which 'know' the size of each list by virtue of a table. + */ + qaddr = &sc->aac_common->ac_qbuf[0] + AAC_QUEUE_ALIGN; + qaddr -= (u_int32_t)qaddr % AAC_QUEUE_ALIGN; + sc->aac_queues = (struct aac_queue_table *)qaddr; + ip->CommHeaderAddress = sc->aac_common_busaddr + ((u_int32_t)sc->aac_queues - (u_int32_t)sc->aac_common); + bzero(sc->aac_queues, sizeof(struct aac_queue_table)); + + sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] = AAC_HOST_NORM_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] = AAC_HOST_NORM_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] = AAC_HOST_HIGH_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] = AAC_HOST_HIGH_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] = AAC_ADAP_NORM_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] = AAC_ADAP_NORM_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] = AAC_ADAP_HIGH_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] = AAC_ADAP_HIGH_CMD_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX] = AAC_HOST_NORM_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX] = AAC_HOST_NORM_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX] = AAC_HOST_HIGH_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX] = AAC_HOST_HIGH_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX] = AAC_ADAP_NORM_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX] = AAC_ADAP_NORM_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX] = AAC_ADAP_HIGH_RESP_ENTRIES; + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX] = AAC_ADAP_HIGH_RESP_ENTRIES; + sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] = &sc->aac_queues->qt_HostNormCmdQueue[0]; + sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] = &sc->aac_queues->qt_HostHighCmdQueue[0]; + sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] = &sc->aac_queues->qt_AdapNormCmdQueue[0]; + sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] = &sc->aac_queues->qt_AdapHighCmdQueue[0]; + sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] = &sc->aac_queues->qt_HostNormRespQueue[0]; + sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] = &sc->aac_queues->qt_HostHighRespQueue[0]; + sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] = &sc->aac_queues->qt_AdapNormRespQueue[0]; + sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] = &sc->aac_queues->qt_AdapHighRespQueue[0]; + + /* + * Do controller-type-specific initialisation + */ + switch (sc->aac_hwif) { + case AAC_HWIF_I960RX: + AAC_SETREG4(sc, AAC_RX_ODBR, ~0); + break; + } + + /* + * Give the init structure to the controller. + */ + if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT, + sc->aac_common_busaddr + fldoff(aac_common, ac_init), + 0, 0, 0, NULL)) { + device_printf(sc->aac_dev, "error establishing init structure\n"); + return(EIO); + } + + return(0); +} + +/******************************************************************************** + * Send a synchronous command to the controller and wait for a result. + */ +static int +aac_sync_command(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3, + u_int32_t *sp) +{ + time_t then; + u_int32_t status; + + debug_called(3); + + /* populate the mailbox */ + AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3); + + /* ensure the sync command doorbell flag is cleared */ + AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND); + + /* then set it to signal the adapter */ + AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND); + + /* spin waiting for the command to complete */ + then = time_second; + do { + if (time_second > (then + AAC_IMMEDIATE_TIMEOUT)) { + debug(2, "timed out"); + return(EIO); + } + } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND)); + + /* clear the completion flag */ + AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND); + + /* get the command status */ + status = AAC_GET_MAILBOXSTATUS(sc); + if (sp != NULL) + *sp = status; + return(0); /* check command return status? */ +} + +/******************************************************************************** + * Send a synchronous FIB to the controller and wait for a result. + */ +static int +aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate, + void *data, u_int16_t datasize, + void *result, u_int16_t *resultsize) +{ + struct aac_fib *fib = &sc->aac_common->ac_sync_fib; + + debug_called(3); + + if (datasize > AAC_FIB_DATASIZE) + return(EINVAL); + + /* + * Set up the sync FIB + */ + fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED | AAC_FIBSTATE_INITIALISED | AAC_FIBSTATE_EMPTY; + fib->Header.XferState |= xferstate; + fib->Header.Command = command; + fib->Header.StructType = AAC_FIBTYPE_TFIB; + fib->Header.Size = sizeof(struct aac_fib) + datasize; + fib->Header.SenderSize = sizeof(struct aac_fib); + fib->Header.SenderFibAddress = (u_int32_t)fib; + fib->Header.ReceiverFibAddress = sc->aac_common_busaddr + fldoff(aac_common, ac_sync_fib); + + /* + * Copy in data. + */ + if (data != NULL) { + bcopy(data, fib->data, datasize); + fib->Header.XferState |= AAC_FIBSTATE_FROMHOST | AAC_FIBSTATE_NORM; + } + + /* + * Give the FIB to the controller, wait for a response. + */ + if (aac_sync_command(sc, AAC_MONKER_SYNCFIB, fib->Header.ReceiverFibAddress, + 0, 0, 0, NULL)) { + debug(2, "IO error"); + return(EIO); + } + + /* + * Copy out the result + */ + if (result != NULL) { + *resultsize = fib->Header.Size - sizeof(struct aac_fib_header); + bcopy(fib->data, result, *resultsize); + } + return(0); +} + +/******************************************************************************** + * Adapter-space FIB queue manipulation + * + * Note that the queue implementation here is a little funky; neither the PI or + * CI will ever be zero. This behaviour is a controller feature. + */ +static struct { + int size; + int notify; +} aac_qinfo[] = { + {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL}, + {AAC_HOST_HIGH_CMD_ENTRIES, 0}, + {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY}, + {AAC_ADAP_HIGH_CMD_ENTRIES, 0}, + {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL}, + {AAC_HOST_HIGH_RESP_ENTRIES, 0}, + {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY}, + {AAC_ADAP_HIGH_RESP_ENTRIES, 0} +}; + +/* + * Atomically insert an entry into the nominated queue, returns 0 on success or EBUSY + * if the queue is full. + * + * XXX note that it would be more efficient to defer notifying the controller in + * the case where we may be inserting several entries in rapid succession, but + * implementing this usefully is difficult. + */ +static int +aac_enqueue_fib(struct aac_softc *sc, int queue, u_int32_t fib_size, u_int32_t fib_addr) +{ + u_int32_t pi, ci; + int s, error; + + debug_called(3); + + s = splbio(); + + /* get the producer/consumer indices */ + pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]; + ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]; + + /* wrap the queue? */ + if (pi >= aac_qinfo[queue].size) + pi = 0; + + /* check for queue full */ + if ((pi + 1) == ci) { + error = EBUSY; + goto out; + } + + /* populate queue entry */ + (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size; + (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr; + + /* update producer index */ + sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1; + + /* notify the adapter if we know how */ + if (aac_qinfo[queue].notify != 0) + AAC_QNOTIFY(sc, aac_qinfo[queue].notify); + + error = 0; + +out: + splx(s); + return(error); +} + +/* + * Atomically remove one entry from the nominated queue, returns 0 on success or ENOENT + * if the queue is empty. + */ +static int +aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size, struct aac_fib **fib_addr) +{ + u_int32_t pi, ci; + int s, error; + + debug_called(3); + + s = splbio(); + + /* get the producer/consumer indices */ + pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]; + ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]; + + /* check for queue empty */ + if (ci == pi) { + error = ENOENT; + goto out; + } + + /* wrap the queue? */ + if (ci >= aac_qinfo[queue].size) + ci = 0; + + /* fetch the entry */ + *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size; + *fib_addr = (struct aac_fib *)(sc->aac_qentries[queue] + ci)->aq_fib_addr; + + /* update consumer index */ + sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1; + + /* if we have made the queue un-full, notify the adapter */ + if (((pi + 1) == ci) && (aac_qinfo[queue].notify != 0)) + AAC_QNOTIFY(sc, aac_qinfo[queue].notify); + error = 0; + +out: + splx(s); + return(error); +} + +/******************************************************************************** + ******************************************************************************** + Interface Function Vectors + ******************************************************************************** + ********************************************************************************/ + +/******************************************************************************** + * Read the current firmware status word. + */ +static int +aac_sa_get_fwstatus(struct aac_softc *sc) +{ + debug_called(3); + + return(AAC_GETREG4(sc, AAC_SA_FWSTATUS)); +} + +static int +aac_rx_get_fwstatus(struct aac_softc *sc) +{ + debug_called(3); + + return(AAC_GETREG4(sc, AAC_RX_FWSTATUS)); +} + +/******************************************************************************** + * Notify the controller of a change in a given queue + */ + +static void +aac_sa_qnotify(struct aac_softc *sc, int qbit) +{ + debug_called(3); + + AAC_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit); +} + +static void +aac_rx_qnotify(struct aac_softc *sc, int qbit) +{ + debug_called(3); + + AAC_SETREG4(sc, AAC_RX_IDBR, qbit); +} + +/******************************************************************************** + * Get the interrupt reason bits + */ +static int +aac_sa_get_istatus(struct aac_softc *sc) +{ + debug_called(3); + + return(AAC_GETREG2(sc, AAC_SA_DOORBELL0)); +} + +static int +aac_rx_get_istatus(struct aac_softc *sc) +{ + debug_called(3); + + return(AAC_GETREG4(sc, AAC_RX_ODBR)); +} + +/******************************************************************************** + * Clear some interrupt reason bits + */ +static void +aac_sa_clear_istatus(struct aac_softc *sc, int mask) +{ + debug_called(3); + + AAC_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask); +} + +static void +aac_rx_clear_istatus(struct aac_softc *sc, int mask) +{ + debug_called(3); + + AAC_SETREG4(sc, AAC_RX_ODBR, mask); +} + +/******************************************************************************** + * Populate the mailbox and set the command word + */ +static void +aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3) +{ + debug_called(4); + + AAC_SETREG4(sc, AAC_SA_MAILBOX, command); + AAC_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0); + AAC_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1); + AAC_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2); + AAC_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3); +} + +static void +aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3) +{ + debug_called(4); + + AAC_SETREG4(sc, AAC_RX_MAILBOX, command); + AAC_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0); + AAC_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1); + AAC_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2); + AAC_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3); +} + +/******************************************************************************** + * Fetch the immediate command status word + */ +static int +aac_sa_get_mailboxstatus(struct aac_softc *sc) +{ + debug_called(4); + + return(AAC_GETREG4(sc, AAC_SA_MAILBOX)); +} + +static int +aac_rx_get_mailboxstatus(struct aac_softc *sc) +{ + debug_called(4); + + return(AAC_GETREG4(sc, AAC_RX_MAILBOX)); +} + +/******************************************************************************** + * Set/clear interrupt masks + */ +static void +aac_sa_set_interrupts(struct aac_softc *sc, int enable) +{ + debug(2, "%sable interrupts", enable ? "en" : "dis"); + + if (enable) { + AAC_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS); + } else { + AAC_SETREG2((sc), AAC_SA_MASK0_SET, ~0); + } +} + +static void +aac_rx_set_interrupts(struct aac_softc *sc, int enable) +{ + debug(2, "%sable interrupts", enable ? "en" : "dis"); + + if (enable) { + AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS); + } else { + AAC_SETREG4(sc, AAC_RX_OIMR, ~0); + } +} + +/******************************************************************************** + ******************************************************************************** + Debugging and Diagnostics + ******************************************************************************** + ********************************************************************************/ + +/******************************************************************************** + * Print some information about the controller. + */ +static void +aac_describe_controller(struct aac_softc *sc) +{ + u_int8_t buf[AAC_FIB_DATASIZE]; /* XXX really a bit big for the stack */ + u_int16_t bufsize; + struct aac_adapter_info *info; + u_int8_t arg; + + debug_called(2); + + arg = 0; + if (aac_sync_fib(sc, RequestAdapterInfo, 0, &arg, sizeof(arg), &buf, &bufsize)) { + device_printf(sc->aac_dev, "RequestAdapterInfo failed\n"); + return; + } + if (bufsize != sizeof(*info)) { + device_printf(sc->aac_dev, "RequestAdapterInfo returned wrong data size (%d != %d)\n", + bufsize, sizeof(*info)); + return; + } + info = (struct aac_adapter_info *)&buf[0]; + + device_printf(sc->aac_dev, "%s %dMHz, %dMB total memory, %s (%d)\n", + aac_describe_code(aac_cpu_variant, info->CpuVariant), info->ClockSpeed, + info->TotalMem / (1024 * 1024), + aac_describe_code(aac_battery_platform, info->batteryPlatform), info->batteryPlatform); + + /* save the kernel revision structure for later use */ + sc->aac_revision = info->KernelRevision; + device_printf(sc->aac_dev, "Kernel %d.%d-%d, S/N %llx\n", + info->KernelRevision.external.comp.major, + info->KernelRevision.external.comp.minor, + info->KernelRevision.external.comp.dash, + info->SerialNumber); /* XXX how is this meant to be formatted? */ +} + +/******************************************************************************** + * Look up a text description of a numeric error code and return a pointer to + * same. + */ +static char * +aac_describe_code(struct aac_code_lookup *table, u_int32_t code) +{ + int i; + + for (i = 0; table[i].string != NULL; i++) + if (table[i].code == code) + return(table[i].string); + return(table[i+1].string); +} + +/***************************************************************************** + ***************************************************************************** + Management Interface + ***************************************************************************** + *****************************************************************************/ + +static int +aac_open(dev_t dev, int flags, int fmt, struct proc *p) +{ + struct aac_softc *sc = dev->si_drv1; + + debug_called(2); + + /* Check to make sure the device isn't already open */ + if (sc->aac_state & AAC_STATE_OPEN) { + return EBUSY; + } + sc->aac_state |= AAC_STATE_OPEN; + + return 0; +} + +static int +aac_close(dev_t dev, int flags, int fmt, struct proc *p) +{ + struct aac_softc *sc = dev->si_drv1; + + debug_called(2); + + /* Mark this unit as no longer open */ + sc->aac_state &= ~AAC_STATE_OPEN; + + return 0; +} + +static int +aac_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct proc *p) +{ + struct aac_softc *sc = dev->si_drv1; + int error = 0, i; + + debug_called(2); + + switch (cmd) { +#ifdef AAC_COMPAT_LINUX + case FSACTL_SENDFIB: + debug(0, "FSACTL_SENDFIB"); + error = aac_ioctl_sendfib(sc, arg); + break; + case FSACTL_AIF_THREAD: + debug(0, "FSACTL_AIF_THREAD"); + error = EINVAL; + break; + case FSACTL_OPEN_GET_ADAPTER_FIB: + debug(0, "FSACTL_OPEN_GET_ADAPTER_FIB"); + /* + * Pass the caller out an AdapterFibContext. + * + * Note that because we only support one opener, we + * basically ignore this. Set the caller's context to a magic + * number just in case. + */ + i = AAC_AIF_SILLYMAGIC; + error = copyout(&i, arg, sizeof(i)); + break; + case FSACTL_GET_NEXT_ADAPTER_FIB: + debug(0, "FSACTL_GET_NEXT_ADAPTER_FIB"); + error = aac_linux_getnext_aif(sc, arg); + break; + case FSACTL_CLOSE_GET_ADAPTER_FIB: + debug(0, "FSACTL_CLOSE_GET_ADAPTER_FIB"); + /* don't do anything here */ + break; + case FSACTL_MINIPORT_REV_CHECK: + debug(0, "FSACTL_MINIPORT_REV_CHECK"); + error = aac_linux_rev_check(sc, arg); + break; +#endif + default: + device_printf(sc->aac_dev, "unsupported cmd 0x%lx\n", cmd); + error = EINVAL; + break; + } + return(error); +} + +/******************************************************************************** + * Send a FIB supplied from userspace + */ +static int +aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib) +{ + struct aac_command *cm; + int size, error; + + debug_called(2); + + cm = NULL; + + /* + * Get a command + */ + if (aac_alloc_command(sc, &cm)) { + error = EBUSY; + goto out; + } + + /* + * Fetch the FIB header, then re-copy to get data as well. + */ + if ((error = copyin(ufib, cm->cm_fib, sizeof(struct aac_fib_header))) != 0) + goto out; + size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header); + if (size > sizeof(struct aac_fib)) { + device_printf(sc->aac_dev, "incoming FIB oversized (%d > %d)\n", size, sizeof(struct aac_fib)); + size = sizeof(struct aac_fib); + } + if ((error = copyin(ufib, cm->cm_fib, size)) != 0) + goto out; + cm->cm_fib->Header.Size = size; + + /* + * Pass the FIB to the controller, wait for it to complete. + */ + if ((error = aac_wait_command(cm, 30)) != 0) /* XXX user timeout? */ + goto out; + + /* + * Copy the FIB and data back out to the caller. + */ + size = cm->cm_fib->Header.Size; + if (size > sizeof(struct aac_fib)) { + device_printf(sc->aac_dev, "outbound FIB oversized (%d > %d)\n", size, sizeof(struct aac_fib)); + size = sizeof(struct aac_fib); + } + error = copyout(cm->cm_fib, ufib, size); + +out: + if (cm != NULL) + aac_release_command(cm); + return(error); +} + +/******************************************************************************** + * Handle an AIF sent to us by the controller; queue it for later reference. + * + * XXX what's the right thing to do here when the queue is full? Drop the older + * or newer entries? + */ +static void +aac_handle_aif(struct aac_softc *sc, struct aac_aif_command *aif) +{ + int next, s; + + debug_called(2); + + s = splbio(); + next = (sc->aac_aifq_head + 1) % AAC_AIFQ_LENGTH; + if (next != sc->aac_aifq_tail) { + bcopy(aif, &sc->aac_aifq[next], sizeof(struct aac_aif_command)); + sc->aac_aifq_head = next; + if (sc->aac_state & AAC_STATE_AIF_SLEEPER) + wakeup(sc->aac_aifq); + } + splx(s); + aac_print_aif(sc, aif); +} + +/******************************************************************************** + * Hand the next AIF off the top of the queue out to userspace. + */ +static int +aac_return_aif(struct aac_softc *sc, caddr_t uptr) +{ + int error, s; + + debug_called(2); + + s = splbio(); + if (sc->aac_aifq_tail == sc->aac_aifq_head) { + error = EAGAIN; + } else { + error = copyout(&sc->aac_aifq[sc->aac_aifq_tail], uptr, sizeof(struct aac_aif_command)); + if (!error) + sc->aac_aifq_tail = (sc->aac_aifq_tail + 1) % AAC_AIFQ_LENGTH; + } + splx(s); + return(error); +} + +/******************************************************************************** + ******************************************************************************** + Linux Management Interface + ******************************************************************************** + ********************************************************************************/ + +#ifdef AAC_COMPAT_LINUX + +#include <machine/../linux/linux.h> +#include <machine/../linux/linux_proto.h> +#include <compat/linux/linux_ioctl.h> + +#define AAC_LINUX_IOCTL_MIN 0x2000 +#define AAC_LINUX_IOCTL_MAX 0x21ff + +static linux_ioctl_function_t aac_linux_ioctl; +static struct linux_ioctl_handler aac_handler = {aac_linux_ioctl, AAC_LINUX_IOCTL_MIN, AAC_LINUX_IOCTL_MAX}; + +SYSINIT (aac_register, SI_SUB_KLD, SI_ORDER_MIDDLE, linux_ioctl_register_handler, &aac_handler); +SYSUNINIT(aac_unregister, SI_SUB_KLD, SI_ORDER_MIDDLE, linux_ioctl_unregister_handler, &aac_handler); + +MODULE_DEPEND(aac, linux, 1, 1, 1); + +static int +aac_linux_ioctl(struct proc *p, struct linux_ioctl_args *args) +{ + struct file *fp = p->p_fd->fd_ofiles[args->fd]; + u_long cmd = args->cmd; + + /* + * Pass the ioctl off to our standard handler. + */ + return(fo_ioctl(fp, cmd, (caddr_t)args->arg, p)); +} + +/******************************************************************************** + * Return the Revision of the driver to the userspace and check to see if the + * userspace app is possibly compatible. This is extremely bogus right now + * because I have no idea how to handle the versioning of this driver. It is + * needed, though, to get aaccli working. + */ +static int +aac_linux_rev_check(struct aac_softc *sc, caddr_t udata) +{ + struct aac_rev_check rev_check; + struct aac_rev_check_resp rev_check_resp; + int error = 0; + + debug_called(2); + + /* + * Copyin the revision struct from userspace + */ + if ((error = copyin(udata, (caddr_t)&rev_check, sizeof(struct aac_rev_check))) != 0) { + return error; + } + + debug(2, "Userland revision= %d\n", rev_check.callingRevision.buildNumber); + + /* + * Doctor up the response struct. + */ + rev_check_resp.possiblyCompatible = 1; + rev_check_resp.adapterSWRevision.external.ul = sc->aac_revision.external.ul; + rev_check_resp.adapterSWRevision.buildNumber = sc->aac_revision.buildNumber; + + return(copyout((caddr_t)&rev_check_resp, udata, sizeof(struct aac_rev_check_resp))); +} + +/******************************************************************************** + * Pass the caller the next AIF in their queue + */ +static int +aac_linux_getnext_aif(struct aac_softc *sc, caddr_t arg) +{ + struct get_adapter_fib_ioctl agf; + int error, s; + + debug_called(2); + + if ((error = copyin(arg, &agf, sizeof(agf))) == 0) { + + /* + * Check the magic number that we gave the caller. + */ + if (agf.AdapterFibContext != AAC_AIF_SILLYMAGIC) { + error = EFAULT; + } else { + + s = splbio(); + error = aac_return_aif(sc, agf.AifFib); + + if ((error == EAGAIN) && (agf.Wait)) { + sc->aac_state |= AAC_STATE_AIF_SLEEPER; + while (error == EAGAIN) { + error = tsleep(sc->aac_aifq, PRIBIO | PCATCH, "aacaif", 0); + if (error == 0) + error = aac_return_aif(sc, agf.AifFib); + } + sc->aac_state &= ~AAC_STATE_AIF_SLEEPER; + } + splx(s); + } + } + return(error); +} + +#endif /* AAC_COMPAT_LINUX */ diff --git a/sys/dev/aac/aac_compat.h b/sys/dev/aac/aac_compat.h new file mode 100644 index 000000000000..26429b596c6e --- /dev/null +++ b/sys/dev/aac/aac_compat.h @@ -0,0 +1,64 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ +/* + * Backwards compatibility support. + */ + +/* + * Handle the new/old bio/buf changeover + */ + +#if __FreeBSD_version < 500003 /* old buf style */ +# include <sys/buf.h> +# define FREEBSD_4 +# define bio buf +# define bioq_init(x) bufq_init(x) +# define bioq_insert_tail(x, y) bufq_insert_tail(x, y) +# define bioq_remove(x, y) bufq_remove(x, y) +# define bioq_first(x) bufq_first(x) +# define bio_queue_head buf_queue_head +# define bio_bcount b_bcount +# define bio_blkno b_blkno +# define bio_caller1 b_caller1 +# define bio_data b_data +# define bio_dev b_dev +# define bio_driver1 b_driver1 +# define bio_driver2 b_driver2 +# define bio_error b_error +# define bio_flags b_flags +# define bio_pblkno b_pblkno +# define bio_resid b_resid +# define BIO_ERROR B_ERROR +# define devstat_end_transaction_bio(x, y) devstat_end_transaction_buf(x, y) +# define BIO_IS_READ(x) ((x)->b_flags & B_READ) + +#else /* new bio style */ +# include <sys/bio.h> +#define BIO_IS_READ(x) ((x)->bio_cmd == BIO_READ) +#endif diff --git a/sys/dev/aac/aac_debug.c b/sys/dev/aac/aac_debug.c new file mode 100644 index 000000000000..09293adeee28 --- /dev/null +++ b/sys/dev/aac/aac_debug.c @@ -0,0 +1,426 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * Debugging support. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> + +#include <dev/aac/aac_compat.h> +#include <sys/bus.h> +#include <sys/devicestat.h> +#include <sys/disk.h> + +#include <machine/resource.h> +#include <machine/bus.h> + +#include <dev/aac/aacreg.h> +#include <dev/aac/aacvar.h> + +void aac_printstate0(void); +void aac_intr0(void); + +/******************************************************************************** + * Dump the command queue indices + */ +void +aac_print_queues(struct aac_softc *sc) +{ + device_printf(sc->aac_dev, "FIB queue header at %p queues at %p\n", + &sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][0], + &sc->aac_queues->qt_HostNormCmdQueue[0]); + device_printf(sc->aac_dev, "HOST_NORM_CMD %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX], + AAC_HOST_NORM_CMD_ENTRIES); + device_printf(sc->aac_dev, "HOST_HIGH_CMD %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX], + AAC_HOST_HIGH_CMD_ENTRIES); + device_printf(sc->aac_dev, "ADAP_NORM_CMD %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX], + AAC_ADAP_NORM_CMD_ENTRIES); + device_printf(sc->aac_dev, "ADAP_HIGH_CMD %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX], + AAC_ADAP_HIGH_CMD_ENTRIES); + device_printf(sc->aac_dev, "HOST_NORM_RESP %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX], + AAC_HOST_NORM_RESP_ENTRIES); + device_printf(sc->aac_dev, "HOST_HIGH_RESP %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX], + AAC_HOST_HIGH_RESP_ENTRIES); + device_printf(sc->aac_dev, "ADAP_NORM_RESP %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX], + AAC_ADAP_NORM_RESP_ENTRIES); + device_printf(sc->aac_dev, "ADAP_HIGH_RESP %d/%d (%d)\n", + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX], + sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX], + AAC_ADAP_HIGH_RESP_ENTRIES); + +} + +/******************************************************************************** + * Print the command queue states for controller 0 (callable from DDB) + */ +void +aac_printstate0(void) +{ + struct aac_softc *sc = devclass_get_softc(aac_devclass, 0); + + aac_print_queues(sc); + switch (sc->aac_hwif) { + case AAC_HWIF_I960RX: + device_printf(sc->aac_dev, "IDBR 0x%08x IIMR 0x%08x IISR 0x%08x\n", + AAC_GETREG4(sc, AAC_RX_IDBR), AAC_GETREG4(sc, AAC_RX_IIMR), AAC_GETREG4(sc, AAC_RX_IISR)); + device_printf(sc->aac_dev, "ODBR 0x%08x OIMR 0x%08x OISR 0x%08x\n", + AAC_GETREG4(sc, AAC_RX_ODBR), AAC_GETREG4(sc, AAC_RX_OIMR), AAC_GETREG4(sc, AAC_RX_OISR)); + AAC_SETREG4(sc, AAC_RX_OIMR, 0/*~(AAC_DB_COMMAND_READY | AAC_DB_RESPONSE_READY | AAC_DB_PRINTF)*/); + device_printf(sc->aac_dev, "ODBR 0x%08x OIMR 0x%08x OISR 0x%08x\n", + AAC_GETREG4(sc, AAC_RX_ODBR), AAC_GETREG4(sc, AAC_RX_OIMR), AAC_GETREG4(sc, AAC_RX_OISR)); + break; + case AAC_HWIF_STRONGARM: + /* XXX implement */ + } +} + +/******************************************************************************** + * simulate an interrupt for controller 0 + */ +void +aac_intr0(void) +{ + struct aac_softc *sc = devclass_get_softc(aac_devclass, 0); + + aac_intr(sc); +} + +/******************************************************************************** + * Panic in a slightly informative fashion + */ +void +aac_panic(struct aac_softc *sc, char *reason) +{ + aac_print_queues(sc); + panic(reason); +} + +/******************************************************************************** + * Print a FIB + */ +void +aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, char *caller) +{ + device_printf(sc->aac_dev, "%s: FIB @ %p\n", caller, fib); + device_printf(sc->aac_dev, " XferState %b\n", fib->Header.XferState, "\20" + "\1HOSTOWNED" + "\2ADAPTEROWNED" + "\3INITIALISED" + "\4EMPTY" + "\5FROMPOOL" + "\6FROMHOST" + "\7FROMADAP" + "\10REXPECTED" + "\11RNOTEXPECTED" + "\12DONEADAP" + "\13DONEHOST" + "\14HIGH" + "\15NORM" + "\16ASYNC" + "\17PAGEFILEIO" + "\20SHUTDOWN" + "\21LAZYWRITE" + "\22ADAPMICROFIB" + "\23BIOSFIB" + "\24FAST_RESPONSE" + "\25APIFIB\n"); + device_printf(sc->aac_dev, " Command %d\n", fib->Header.Command); + device_printf(sc->aac_dev, " StructType %d\n", fib->Header.StructType); + device_printf(sc->aac_dev, " Flags 0x%x\n", fib->Header.Flags); + device_printf(sc->aac_dev, " Size %d\n", fib->Header.Size); + device_printf(sc->aac_dev, " SenderSize %d\n", fib->Header.SenderSize); + device_printf(sc->aac_dev, " SenderAddress 0x%x\n", fib->Header.SenderFibAddress); + device_printf(sc->aac_dev, " ReceiverAddress 0x%x\n", fib->Header.ReceiverFibAddress); + device_printf(sc->aac_dev, " SenderData 0x%x\n", fib->Header.SenderData); + switch(fib->Header.Command) { + case ContainerCommand: + { + struct aac_blockread *br = (struct aac_blockread *)fib->data; + struct aac_blockwrite *bw = (struct aac_blockwrite *)fib->data; + struct aac_sg_table *sg = NULL; + int i; + if (br->Command == VM_CtBlockRead) { + device_printf(sc->aac_dev, " BlockRead: container %d 0x%x/%d\n", + br->ContainerId, br->BlockNumber, br->ByteCount); + sg = &br->SgMap; + } + if (bw->Command == VM_CtBlockWrite) { + device_printf(sc->aac_dev, " BlockWrite: container %d 0x%x/%d (%s)\n", + bw->ContainerId, bw->BlockNumber, bw->ByteCount, + bw->Stable == CSTABLE ? "stable" : "unstable"); + sg = &bw->SgMap; + } + if (sg != NULL) { + device_printf(sc->aac_dev, " %d s/g entries\n", sg->SgCount); + for (i = 0; i < sg->SgCount; i++) + device_printf(sc->aac_dev, " 0x%08x/%d\n", sg->SgEntry[i].SgAddress, sg->SgEntry[i].SgByteCount); + } + break; + } + default: + device_printf(sc->aac_dev, " %16D\n", fib->data, " "); + device_printf(sc->aac_dev, " %16D\n", fib->data + 16, " "); + break; + } +} + +/******************************************************************************** + * Describe an AIF we have received. + */ +void +aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif) +{ + switch(aif->command) { + case AifCmdEventNotify: + device_printf(sc->aac_dev, "EventNotify (%d)\n", aif->seqNumber); + switch(aif->data.EN.type) { + case AifEnGeneric: /* Generic notification */ + device_printf(sc->aac_dev, "(Generic) %.*s\n", + (int)sizeof(aif->data.EN.data.EG), aif->data.EN.data.EG.text); + break; + case AifEnTaskComplete: /* Task has completed */ + device_printf(sc->aac_dev, "(TaskComplete)\n"); + break; + case AifEnConfigChange: /* Adapter configuration change occurred */ + device_printf(sc->aac_dev, "(ConfigChange)\n"); + break; + case AifEnContainerChange: /* Adapter specific container configuration change */ + device_printf(sc->aac_dev, "(ContainerChange) container %d,%d\n", + aif->data.EN.data.ECC.container[0], + aif->data.EN.data.ECC.container[1]); + break; + case AifEnDeviceFailure: /* SCSI device failed */ + device_printf(sc->aac_dev, "(DeviceFailure) handle %d\n", + aif->data.EN.data.EDF.deviceHandle); /* XXX interpret */ + break; + case AifEnMirrorFailover: /* Mirror failover started */ + device_printf(sc->aac_dev, "(MirrorFailover) container %d failed, migrating from slice %d to %d\n", + aif->data.EN.data.EMF.container, + aif->data.EN.data.EMF.failedSlice, + aif->data.EN.data.EMF.creatingSlice); + break; + case AifEnContainerEvent: /* Significant container event */ + device_printf(sc->aac_dev, "(ContainerEvent) container %d event %d\n", + aif->data.EN.data.ECE.container, + aif->data.EN.data.ECE.eventType); /* XXX interpret? */ + break; + case AifEnFileSystemChange: /* File system changed */ + device_printf(sc->aac_dev, "(FileSystemChange)\n"); + break; + case AifEnConfigPause: /* Container pause event */ + device_printf(sc->aac_dev, "(ConfigPause)\n"); + break; + case AifEnConfigResume: /* Container resume event */ + device_printf(sc->aac_dev, "(ConfigResume)\n"); + break; + case AifEnFailoverChange: /* Failover space assignment changed */ + device_printf(sc->aac_dev, "(FailoverChange)\n"); + break; + case AifEnRAID5RebuildDone: /* RAID5 rebuild finished */ + device_printf(sc->aac_dev, "(RAID5RebuildDone)\n"); + break; + case AifEnEnclosureManagement: /* Enclosure management event */ + device_printf(sc->aac_dev, "(EnclosureManagement) EMPID %d unit %d event %d\n", + aif->data.EN.data.EEE.empID, + aif->data.EN.data.EEE.unitID, + aif->data.EN.data.EEE.eventType); + break; + case AifEnBatteryEvent: /* Significant NV battery event */ + device_printf(sc->aac_dev, "(BatteryEvent) %d (state was %d, is %d)\n", + aif->data.EN.data.EBE.transition_type, /* XXX interpret */ + aif->data.EN.data.EBE.current_state, + aif->data.EN.data.EBE.prior_state); + break; + case AifEnAddContainer: /* A new container was created. */ + device_printf(sc->aac_dev, "(AddContainer)\n"); + break; + case AifEnDeleteContainer: /* A container was deleted. */ + device_printf(sc->aac_dev, "(DeleteContainer)\n"); + break; + case AifEnBatteryNeedsRecond: /* The battery needs reconditioning */ + device_printf(sc->aac_dev, "(BatteryNeedsRecond)\n"); + break; + case AifEnClusterEvent: /* Some cluster event */ + device_printf(sc->aac_dev, "(ClusterEvent) event %d\n", + aif->data.EN.data.ECLE.eventType); + break; + case AifEnDiskSetEvent: /* A disk set event occured. */ + device_printf(sc->aac_dev, "(DiskSetEvent) event %d diskset %lld creator %lld\n", + aif->data.EN.data.EDS.eventType, + aif->data.EN.data.EDS.DsNum, + aif->data.EN.data.EDS.CreatorId); + break; + case AifDenMorphComplete: /* A morph operation completed */ + device_printf(sc->aac_dev, "(MorphComplete)\n"); + break; + case AifDenVolumeExtendComplete: /* A volume expand operation completed */ + device_printf(sc->aac_dev, "(VolumeExtendComplete)\n"); + break; + default: + device_printf(sc->aac_dev, "(%d)\n", aif->data.EN.type); + break; + } + break; + case AifCmdJobProgress: + { + char *status; + switch(aif->data.PR[0].status) { + case AifJobStsSuccess: + status = "success"; break; + case AifJobStsFinished: + status = "finished"; break; + case AifJobStsAborted: + status = "aborted"; break; + case AifJobStsFailed: + status = "failed"; break; + case AifJobStsSuspended: + status = "suspended"; break; + case AifJobStsRunning: + status = "running"; break; + default: + status = "unknown status"; break; + } + + device_printf(sc->aac_dev, "JobProgress (%d) - %s (%d, %d)\n", aif->seqNumber, status, + aif->data.PR[0].currentTick, aif->data.PR[0].finalTick); + switch(aif->data.PR[0].jd.type) { + case AifJobScsiZero: /* SCSI device clear operation */ + device_printf(sc->aac_dev, "(ScsiZero) handle %d\n", aif->data.PR[0].jd.client.scsi_dh); + break; + case AifJobScsiVerify: /* SCSI device Verify operation NO REPAIR */ + device_printf(sc->aac_dev, "(ScsiVerify) handle %d\n", aif->data.PR[0].jd.client.scsi_dh); + break; + case AifJobScsiExercise: /* SCSI device Exercise operation */ + device_printf(sc->aac_dev, "(ScsiExercise) handle %d\n", aif->data.PR[0].jd.client.scsi_dh); + break; + case AifJobScsiVerifyRepair: /* SCSI device Verify operation WITH repair */ + device_printf(sc->aac_dev, "(ScsiVerifyRepair) handle %d\n", aif->data.PR[0].jd.client.scsi_dh); + break; + case AifJobCtrZero: /* Container clear operation */ + device_printf(sc->aac_dev, "(ConatainerZero) container %d\n", + aif->data.PR[0].jd.client.container.src); + break; + case AifJobCtrCopy: /* Container copy operation */ + device_printf(sc->aac_dev, "(ConatainerCopy) container %d to %d\n", + aif->data.PR[0].jd.client.container.src, aif->data.PR[0].jd.client.container.dst); + break; + case AifJobCtrCreateMirror: /* Container Create Mirror operation */ + device_printf(sc->aac_dev, "(ConatainerCreateMirror) container %d\n", + aif->data.PR[0].jd.client.container.src); /* XXX two containers? */ + break; + case AifJobCtrMergeMirror: /* Container Merge Mirror operation */ + device_printf(sc->aac_dev, "(ConatainerMergeMirror) container %d\n", + aif->data.PR[0].jd.client.container.src); /* XXX two containers? */ + break; + case AifJobCtrScrubMirror: /* Container Scrub Mirror operation */ + device_printf(sc->aac_dev, "(ConatainerScrubMirror) container %d\n", + aif->data.PR[0].jd.client.container.src); + break; + case AifJobCtrRebuildRaid5: /* Container Rebuild Raid5 operation */ + device_printf(sc->aac_dev, "(ConatainerRebuildRaid5) container %d\n", + aif->data.PR[0].jd.client.container.src); + break; + case AifJobCtrScrubRaid5: /* Container Scrub Raid5 operation */ + device_printf(sc->aac_dev, "(ConatainerScrubRaid5) container %d\n", + aif->data.PR[0].jd.client.container.src); + break; + case AifJobCtrMorph: /* Container morph operation */ + device_printf(sc->aac_dev, "(ConatainerMorph) container %d\n", + aif->data.PR[0].jd.client.container.src); /* XXX two containers? */ + break; + case AifJobCtrPartCopy: /* Container Partition copy operation */ + device_printf(sc->aac_dev, "(ConatainerPartCopy) container %d to %d\n", + aif->data.PR[0].jd.client.container.src, aif->data.PR[0].jd.client.container.dst); + break; + case AifJobCtrRebuildMirror: /* Container Rebuild Mirror operation */ + device_printf(sc->aac_dev, "(ConatainerRebuildMirror) container %d\n", + aif->data.PR[0].jd.client.container.src); + break; + case AifJobCtrCrazyCache: /* crazy cache */ + device_printf(sc->aac_dev, "(ConatainerCrazyCache) container %d\n", + aif->data.PR[0].jd.client.container.src); /* XXX two containers? */ + break; + case AifJobFsCreate: /* File System Create operation */ + device_printf(sc->aac_dev, "(FsCreate)\n"); + break; + case AifJobFsVerify: /* File System Verify operation */ + device_printf(sc->aac_dev, "(FsVerivy)\n"); + break; + case AifJobFsExtend: /* File System Extend operation */ + device_printf(sc->aac_dev, "(FsExtend)\n"); + break; + case AifJobApiFormatNTFS: /* Format a drive to NTFS */ + device_printf(sc->aac_dev, "(FormatNTFS)\n"); + break; + case AifJobApiFormatFAT: /* Format a drive to FAT */ + device_printf(sc->aac_dev, "(FormatFAT)\n"); + break; + case AifJobApiUpdateSnapshot: /* update the read/write half of a snapshot */ + device_printf(sc->aac_dev, "(UpdateSnapshot)\n"); + break; + case AifJobApiFormatFAT32: /* Format a drive to FAT32 */ + device_printf(sc->aac_dev, "(FormatFAT32)\n"); + break; + case AifJobCtlContinuousCtrVerify: /* Adapter operation */ + device_printf(sc->aac_dev, "(ContinuousCtrVerify)\n"); + break; + default: + device_printf(sc->aac_dev, "(%d)\n", aif->data.PR[0].jd.type); + break; + } + break; + } + case AifCmdAPIReport: + device_printf(sc->aac_dev, "APIReport (%d)\n", aif->seqNumber); + break; + case AifCmdDriverNotify: + device_printf(sc->aac_dev, "DriverNotify (%d)\n", aif->seqNumber); + break; + default: + device_printf(sc->aac_dev, "AIF %d (%d)\n", aif->command, aif->seqNumber); + break; + } +} diff --git a/sys/dev/aac/aac_disk.c b/sys/dev/aac/aac_disk.c new file mode 100644 index 000000000000..b2028ece6d8e --- /dev/null +++ b/sys/dev/aac/aac_disk.c @@ -0,0 +1,296 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> + +#include <dev/aac/aac_compat.h> +#include <sys/bus.h> +#include <sys/conf.h> +#include <sys/devicestat.h> +#include <sys/disk.h> + +#include <machine/bus.h> +#include <machine/clock.h> +#include <sys/rman.h> + +#include <dev/aac/aacreg.h> +#include <dev/aac/aacvar.h> + +/* + * Interface to parent. + */ +static int aac_disk_probe(device_t dev); +static int aac_disk_attach(device_t dev); +static int aac_disk_detach(device_t dev); + +/* + * Interface to the device switch. + */ +static d_open_t aac_disk_open; +static d_close_t aac_disk_close; +static d_strategy_t aac_disk_strategy; + +#define AAC_DISK_CDEV_MAJOR 151 + +static struct cdevsw aac_disk_cdevsw = { + /* open */ aac_disk_open, + /* close */ aac_disk_close, + /* read */ physread, + /* write */ physwrite, + /* ioctl */ noioctl, + /* poll */ nopoll, + /* mmap */ nommap, + /* strategy */ aac_disk_strategy, + /* name */ "aacd", + /* maj */ AAC_DISK_CDEV_MAJOR, + /* dump */ nodump, + /* psize */ nopsize, + /* flags */ D_DISK, + /* bmaj */ -1 +}; + +devclass_t aac_disk_devclass; +static struct cdevsw aac_disk_disk_cdevsw; +#ifdef FREEBSD_4 +static int disks_registered = 0; +#endif + +static device_method_t aac_disk_methods[] = { + DEVMETHOD(device_probe, aac_disk_probe), + DEVMETHOD(device_attach, aac_disk_attach), + DEVMETHOD(device_detach, aac_disk_detach), + { 0, 0 } +}; + +static driver_t aac_disk_driver = { + "aacd", + aac_disk_methods, + sizeof(struct aac_disk) +}; + +DRIVER_MODULE(aacd, aac, aac_disk_driver, aac_disk_devclass, 0, 0); + +/******************************************************************************** + * Handle open from generic layer. + * + * This is called by the diskslice code on first open in order to get the + * basic device geometry paramters. + */ +static int +aac_disk_open(dev_t dev, int flags, int fmt, struct proc *p) +{ + struct aac_disk *sc = (struct aac_disk *)dev->si_drv1; + struct disklabel *label; + + debug_called(4); + + if (sc == NULL) + return (ENXIO); + + /* check that the controller is up and running */ + if (sc->ad_controller->aac_state & AAC_STATE_SUSPEND) + return(ENXIO); + + /* build synthetic label */ + label = &sc->ad_disk.d_label; + bzero(label, sizeof(*label)); + label->d_type = DTYPE_ESDI; + label->d_secsize = AAC_BLOCK_SIZE; + label->d_nsectors = sc->ad_sectors; + label->d_ntracks = sc->ad_heads; + label->d_ncylinders = sc->ad_cylinders; + label->d_secpercyl = sc->ad_sectors * sc->ad_heads; + label->d_secperunit = sc->ad_size; + + sc->ad_flags |= AAC_DISK_OPEN; + return (0); +} + +/******************************************************************************** + * Handle last close of the disk device. + */ +static int +aac_disk_close(dev_t dev, int flags, int fmt, struct proc *p) +{ + struct aac_disk *sc = (struct aac_disk *)dev->si_drv1; + + debug_called(4); + + if (sc == NULL) + return (ENXIO); + + sc->ad_flags &= ~AAC_DISK_OPEN; + return (0); +} + +/******************************************************************************** + * Handle an I/O request. + */ +static void +aac_disk_strategy(struct bio *bp) +{ + struct aac_disk *sc = (struct aac_disk *)bp->bio_dev->si_drv1; + + debug_called(4); + + /* bogus disk? */ + if (sc == NULL) { + bp->bio_flags |= BIO_ERROR; + bp->bio_error = EINVAL; + biodone(bp); + return; + } + + /* do-nothing operation? */ + if (bp->bio_bcount == 0) { + bp->bio_resid = bp->bio_bcount; + biodone(bp); + return; + } + + /* perform accounting */ + devstat_start_transaction(&sc->ad_stats); + + /* pass the bio to the controller - it can work out who we are */ + aac_submit_bio(bp); + return; +} + +/******************************************************************************** + * Handle completion of an I/O request. + */ +void +aac_complete_bio(struct bio *bp) +{ + struct aac_disk *sc = (struct aac_disk *)bp->bio_dev->si_drv1; + + debug_called(4); + + devstat_end_transaction_bio(&sc->ad_stats, bp); + biodone(bp); +} + +/******************************************************************************** + * Stub only. + */ +static int +aac_disk_probe(device_t dev) +{ + + debug_called(4); + + return (0); +} + +/******************************************************************************** + * Attach a unit to the controller. + */ +static int +aac_disk_attach(device_t dev) +{ + struct aac_disk *sc = (struct aac_disk *)device_get_softc(dev); + int sgspace; + int maxsg; + + debug_called(4); + + /* initialise our softc */ + sc->ad_controller = (struct aac_softc *)device_get_softc(device_get_parent(dev)); + sc->ad_container = device_get_ivars(dev); + sc->ad_dev = dev; + + /* require that extended translation be enabled XXX document! */ + sc->ad_size = sc->ad_container->co_mntobj.Capacity; + if (sc->ad_size >= (2 * 1024 * 1024)) { /* 2GB */ + sc->ad_heads = 255; + sc->ad_sectors = 63; + } else if (sc->ad_size >= (2 * 1024 * 1024)) { /* 1GB */ + sc->ad_heads = 128; + sc->ad_sectors = 32; + } else { + sc->ad_heads = 64; + sc->ad_sectors = 32; + } + sc->ad_cylinders = (sc->ad_size / (sc->ad_heads * sc->ad_sectors)); + + device_printf(dev, "%uMB (%u sectors)\n", + sc->ad_size / ((1024 * 1024) / AAC_BLOCK_SIZE), sc->ad_size); + + devstat_add_entry(&sc->ad_stats, "aacd", device_get_unit(dev), AAC_BLOCK_SIZE, + DEVSTAT_NO_ORDERED_TAGS, + DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER, + DEVSTAT_PRIORITY_ARRAY); + + /* attach a generic disk device to ourselves */ + sc->ad_dev_t = disk_create(device_get_unit(dev), &sc->ad_disk, 0, &aac_disk_cdevsw, &aac_disk_disk_cdevsw); + sc->ad_dev_t->si_drv1 = sc; +#ifdef FREEBSD_4 + disks_registered++; +#endif + + /* + * We can calculate the maximum number of s/g entries based on the size of the + * FIB and the command structures packed within it. + */ + sgspace = (sizeof(struct aac_fib) - sizeof(struct aac_fib_header) - + imax(sizeof(struct aac_blockwrite), sizeof(struct aac_blockread))); + maxsg = (sgspace - sizeof(struct aac_sg_table)) / sizeof(struct aac_sg_entry); + + /* set the maximum I/O size to the theoretical worst maximum allowed by the S/G list size */ + sc->ad_dev_t->si_iosize_max = (maxsg - 1) * PAGE_SIZE; + + return (0); +} + +/******************************************************************************** + * Disconnect ourselves from the system. + */ +static int +aac_disk_detach(device_t dev) +{ + struct aac_disk *sc = (struct aac_disk *)device_get_softc(dev); + + debug_called(4); + + if (sc->ad_flags & AAC_DISK_OPEN) + return(EBUSY); + + devstat_remove_entry(&sc->ad_stats); +#ifdef FREEBSD_4 + if (--disks_registered == 0) + cdevsw_remove(&aac_disk_disk_cdevsw); +#else + disk_destroy(sc->ad_dev_t); +#endif + + return(0); +} + diff --git a/sys/dev/aac/aac_ioctl.h b/sys/dev/aac/aac_ioctl.h new file mode 100644 index 000000000000..354c0aa5cddc --- /dev/null +++ b/sys/dev/aac/aac_ioctl.h @@ -0,0 +1,78 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 Scott Long + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifdef AAC_COMPAT_LINUX + +/* + * Ioctl commands likely to be submitted from a Linux management application. + * These bit encodings are actually descended from Windows NT. Ick. + */ + +#define CTL_CODE(devType, func, meth, acc) (((devType) << 16) | ((acc) << 14) | ((func) << 2) | (meth)) +#define METHOD_BUFFERED 0 +#define METHOD_IN_DIRECT 1 +#define METHOD_OUT_DIRECT 2 +#define METHOD_NEITHER 3 +#define FILE_ANY_ACCESS 0 +#define FILE_READ_ACCESS ( 0x0001 ) +#define FILE_WRITE_ACCESS ( 0x0002 ) +#define FILE_DEVICE_CONTROLLER 0x00000004 + +#define FSACTL_SENDFIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2050, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_AIF_THREAD CTL_CODE(FILE_DEVICE_CONTROLLER, 2127, METHOD_NEITHER, FILE_ANY_ACCESS) +#define FSACTL_OPEN_GET_ADAPTER_FIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2100, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_GET_NEXT_ADAPTER_FIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2101, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_CLOSE_GET_ADAPTER_FIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2102, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_MINIPORT_REV_CHECK CTL_CODE(FILE_DEVICE_CONTROLLER, 2107, METHOD_BUFFERED, FILE_ANY_ACCESS) + +/* + * Support for faking the "miniport" version. + */ +struct aac_rev_check { + RevComponent callingComponent; + struct FsaRevision callingRevision; +}; + +struct aac_rev_check_resp { + int possiblyCompatible; + struct FsaRevision adapterSWRevision; +}; + +/* + * Context passed in by a consumer looking to collect an AIF. + */ +#define AAC_AIF_SILLYMAGIC 0xdeadbeef +struct get_adapter_fib_ioctl { + u_int32_t AdapterFibContext; + int Wait; + caddr_t AifFib; +}; + +#endif diff --git a/sys/dev/aac/aac_pci.c b/sys/dev/aac/aac_pci.c new file mode 100644 index 000000000000..f931bd1b1f7b --- /dev/null +++ b/sys/dev/aac/aac_pci.c @@ -0,0 +1,272 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * PCI bus interface and resource allocation. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> + +#include <dev/aac/aac_compat.h> +#include <sys/bus.h> +#include <sys/conf.h> +#include <sys/devicestat.h> +#include <sys/disk.h> + +#include <machine/bus_memio.h> +#include <machine/bus.h> +#include <machine/resource.h> +#include <sys/rman.h> + +#include <pci/pcireg.h> +#include <pci/pcivar.h> + +#include <dev/aac/aacreg.h> +#include <dev/aac/aacvar.h> + +static int aac_pci_probe(device_t dev); +static int aac_pci_attach(device_t dev); + +static device_method_t aac_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, aac_pci_probe), + DEVMETHOD(device_attach, aac_pci_attach), + DEVMETHOD(device_detach, aac_detach), + DEVMETHOD(device_shutdown, aac_shutdown), + DEVMETHOD(device_suspend, aac_suspend), + DEVMETHOD(device_resume, aac_resume), + + DEVMETHOD(bus_print_child, bus_generic_print_child), + DEVMETHOD(bus_driver_added, bus_generic_driver_added), + { 0, 0 } +}; + +static driver_t aac_pci_driver = { + "aac", + aac_methods, + sizeof(struct aac_softc) +}; + +DRIVER_MODULE(aac, pci, aac_pci_driver, aac_devclass, 0, 0); + +struct aac_ident +{ + u_int16_t vendor; + u_int16_t device; + u_int16_t subvendor; + u_int16_t subdevice; + int hwif; + char *desc; +} aac_identifiers[] = { + {0x1028, 0x0001, 0x1028, 0x0001, AAC_HWIF_I960RX, "Dell PERC 2/Si"}, + {0x1028, 0x0002, 0x1028, 0x0002, AAC_HWIF_I960RX, "Dell PERC 3/Di"}, + {0x1028, 0x0003, 0x1028, 0x0003, AAC_HWIF_I960RX, "Dell PERC 3/Si"}, + {0x9005, 0x0282, 0x9005, 0x0282, AAC_HWIF_I960RX, "Adaptec AAC-2622"}, + {0x1011, 0x0046, 0x9005, 0x0364, AAC_HWIF_STRONGARM, "Adaptec AAC-364"}, + {0x1011, 0x0046, 0x9005, 0x0365, AAC_HWIF_STRONGARM, "Adaptec AAC-3642"}, + {0x1011, 0x0046, 0x9005, 0x1364, AAC_HWIF_STRONGARM, "Dell PERC 2/QC"}, + {0x1011, 0x0046, 0x9005, 0x1365, AAC_HWIF_STRONGARM, "Dell PERC 3/QC"}, /* XXX guess */ + {0x1011, 0x0046, 0x103c, 0x10c2, AAC_HWIF_STRONGARM, "HP NetRaid-4M"}, + {0, 0, 0, 0, 0, 0} +}; + +/******************************************************************************** + * Determine whether this is one of our supported adapters. + */ +static int +aac_pci_probe(device_t dev) +{ + struct aac_ident *m; + + debug_called(1); + + for (m = aac_identifiers; m->vendor != 0; m++) { + if ((m->vendor == pci_get_vendor(dev)) && + (m->device == pci_get_device(dev)) && + ((m->subvendor == 0) || (m->subvendor == pci_get_subvendor(dev))) && + ((m->subdevice == 0) || ((m->subdevice == pci_get_subdevice(dev))))) { + + device_set_desc(dev, m->desc); + return(0); + } + } + return(ENXIO); +} + +/******************************************************************************** + * Allocate resources for our device, set up the bus interface. + */ +static int +aac_pci_attach(device_t dev) +{ + struct aac_softc *sc; + int i, error; + u_int32_t command; + + debug_called(1); + + /* + * Initialise softc. + */ + sc = device_get_softc(dev); + bzero(sc, sizeof(*sc)); + sc->aac_dev = dev; + + /* assume failure is 'not configured' */ + error = ENXIO; + + /* + * Verify that the adapter is correctly set up in PCI space. + */ + command = pci_read_config(sc->aac_dev, PCIR_COMMAND, 2); + command |= PCIM_CMD_BUSMASTEREN; + pci_write_config(dev, PCIR_COMMAND, command, 2); + command = pci_read_config(sc->aac_dev, PCIR_COMMAND, 2); + if (!(command & PCIM_CMD_BUSMASTEREN)) { + device_printf(sc->aac_dev, "can't enable bus-master feature\n"); + goto out; + } + if ((command & PCIM_CMD_MEMEN) == 0) { + device_printf(sc->aac_dev, "memory window not available\n"); + goto out; + } + + /* + * Allocate the PCI register window. + */ + sc->aac_regs_rid = 0x10; /* first base address register */ + if ((sc->aac_regs_resource = bus_alloc_resource(sc->aac_dev, SYS_RES_MEMORY, &sc->aac_regs_rid, + 0, ~0, 1, RF_ACTIVE)) == NULL) { + device_printf(sc->aac_dev, "couldn't allocate register window\n"); + goto out; + } + sc->aac_btag = rman_get_bustag(sc->aac_regs_resource); + sc->aac_bhandle = rman_get_bushandle(sc->aac_regs_resource); + + /* + * Allocate and connect our interrupt. + */ + sc->aac_irq_rid = 0; + if ((sc->aac_irq = bus_alloc_resource(sc->aac_dev, SYS_RES_IRQ, &sc->aac_irq_rid, + 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE)) == NULL) { + device_printf(sc->aac_dev, "can't allocate interrupt\n"); + goto out; + } + if (bus_setup_intr(sc->aac_dev, sc->aac_irq, INTR_TYPE_BIO, aac_intr, sc, &sc->aac_intr)) { + device_printf(sc->aac_dev, "can't set up interrupt\n"); + goto out; + } + + /* assume failure is 'out of memory' */ + error = ENOMEM; + + /* + * Allocate the parent bus DMA tag appropriate for our PCI interface. + * + * Note that some of these controllers are 64-bit capable. + */ + if (bus_dma_tag_create(NULL, /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + MAXBSIZE, AAC_MAXSGENTRIES, /* maxsize, nsegments */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ + BUS_DMA_ALLOCNOW, /* flags */ + &sc->aac_parent_dmat)) { + device_printf(sc->aac_dev, "can't allocate parent DMA tag\n"); + goto out; + } + + /* + * Create DMA tag for mapping buffers into controller-addressable space. + */ + if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + MAXBSIZE, AAC_MAXSGENTRIES, /* maxsize, nsegments */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ + 0, /* flags */ + &sc->aac_buffer_dmat)) { + device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n"); + goto out; + } + + /* + * Create DMA tag for mapping FIBs into controller-addressable space.. + */ + if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + AAC_CLUSTER_COUNT * sizeof(struct aac_fib), 1,/* maxsize, nsegments */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ + 0, /* flags */ + &sc->aac_fib_dmat)) { + device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n"); + goto out; + } + + /* + * Detect the hardware interface version, set up the bus interface indirection. + */ + for (i = 0; aac_identifiers[i].vendor != 0; i++) { + if ((aac_identifiers[i].vendor == pci_get_vendor(dev)) && + (aac_identifiers[i].device == pci_get_device(dev))) { + sc->aac_hwif = aac_identifiers[i].hwif; + switch(sc->aac_hwif) { + case AAC_HWIF_I960RX: + debug(2, "set hardware up for i960Rx"); + sc->aac_if = aac_rx_interface; + break; + + case AAC_HWIF_STRONGARM: + debug(2, "set hardware up for StrongARM"); + sc->aac_if = aac_sa_interface; + break; + } + break; + } + } + + /* + * Do bus-independent initialisation. + */ + error = aac_attach(sc); + +out: + if (error) + aac_free(sc); + return(error); +} diff --git a/sys/dev/aac/aac_tables.h b/sys/dev/aac/aac_tables.h new file mode 100644 index 000000000000..d994ae622181 --- /dev/null +++ b/sys/dev/aac/aac_tables.h @@ -0,0 +1,117 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * Status codes for block read/write commands, etc. + * + * XXX many of these would not normally be returned, as they are + * relevant only to FSA operations. + */ +static struct aac_code_lookup aac_command_status_table[] = { + {"OK", 0}, + {"operation not permitted", 1}, + {"not found", 2}, + {"I/O error", 5}, + {"device not configured", 6}, + {"too big", 7}, + {"permission denoed", 13}, + {"file exists", 17}, + {"cross-device link", 18}, + {"operation not supported by device", 19}, + {"not a directory", 20}, + {"is a directory", 21}, + {"invalid argument", 22}, + {"file too large", 27}, + {"no space on device", 28}, + {"readonly filesystem", 30}, + {"too many links", 31}, + {"operation would block", 35}, + {"file name too long", 63}, + {"directory not empty", 66}, + {"quota exceeded", 69}, + {"stale file handle", 70}, + {"too many levels of remote in path", 71}, + {"bad file handle", 10001}, + {"not sync", 10002}, + {"bad cookie", 10003}, + {"operation not supported", 10004}, + {"too small", 10005}, + {"server fault", 10006}, + {"bad type", 10007}, + {"jukebox", 10008}, + {"not mounted", 10009}, + {"in maintenace mode", 10010}, + {"stale ACL", 10011}, + {NULL, 0}, + {"unknown command status", 0} +}; + +#define AAC_COMMAND_STATUS(x) aac_describe_code(aac_command_status_table, x) + +static struct aac_code_lookup aac_cpu_variant[] = { + {"i960JX", CPUI960_JX}, + {"i960CX", CPUI960_CX}, + {"i960HX", CPUI960_HX}, + {"i960RX", CPUI960_RX}, + {"StrongARM SA110", CPUARM_SA110}, + {"PowerPC 603e", CPUPPC_603e}, + {"Unknown StrongARM", CPUARM_xxx}, + {"Unknown PowerPC", CPUPPC_xxx}, + {NULL, 0}, + {"Unknown processor", 0} +}; + +static struct aac_code_lookup aac_battery_platform[] = { + {"required battery present", PLATFORM_BAT_REQ_PRESENT}, + {"REQUIRED BATTERY NOT PRESENT", PLATFORM_BAT_REQ_NOTPRESENT}, + {"optional battery present", PLATFORM_BAT_OPT_PRESENT}, + {"optional battery not installed", PLATFORM_BAT_OPT_NOTPRESENT}, + {"no battery support", PLATFORM_BAT_NOT_SUPPORTED}, + {NULL, 0}, + {"unknown battery platform", 0} +}; + +static struct aac_code_lookup aac_container_types[] = { + {"Volume", CT_VOLUME}, + {"RAID 1 (Mirror)", CT_MIRROR}, + {"RAID 0 (Stripe)", CT_STRIPE}, + {"RAID 5", CT_RAID5}, + {"SSRW", CT_SSRW}, + {"SSRO", CT_SSRO}, + {"Morph", CT_MORPH}, + {"Passthrough", CT_PASSTHRU}, + {"RAID 4", CT_RAID4}, + {"RAID 10", CT_RAID10}, + {"RAID 00", CT_RAID00}, + {"Volume of Mirrors", CT_VOLUME_OF_MIRRORS}, + {"Pseudo RAID 3", CT_PSEUDO_RAID3}, + {NULL, 0}, + {"unknown", 0} +}; + diff --git a/sys/dev/aac/aacreg.h b/sys/dev/aac/aacreg.h new file mode 100644 index 000000000000..df5ad9af60d6 --- /dev/null +++ b/sys/dev/aac/aacreg.h @@ -0,0 +1,1082 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 Scott Long + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * Data structures defining the interface between the driver and the Adaptec + * 'FSA' adapters. Note that many field names and comments here are taken + * verbatim from the Adaptec driver source in order to make comparing the + * two slightly easier. + */ + +/******************************************************************************** + * Misc. magic numbers. + */ +#define AAC_MAX_CONTAINERS 64 +#define AAC_BLOCK_SIZE 512 + +/******************************************************************************** + * Communications interface. + * + * Where datastructure layouts are closely parallel to the Adaptec sample code, + * retain their naming conventions (for now) to aid in cross-referencing. + */ + +/* + * We establish 4 command queues and matching response queues. Queues must + * be 16-byte aligned, and are sized as follows: + */ +#define AAC_HOST_NORM_CMD_ENTRIES 8 /* command adapter->host, normal priority */ +#define AAC_HOST_HIGH_CMD_ENTRIES 4 /* command adapter->host, high priority */ +#define AAC_ADAP_NORM_CMD_ENTRIES 512 /* command host->adapter, normal priority */ +#define AAC_ADAP_HIGH_CMD_ENTRIES 4 /* command host->adapter, high priority */ +#define AAC_HOST_NORM_RESP_ENTRIES 512 /* response, adapter->host, normal priority */ +#define AAC_HOST_HIGH_RESP_ENTRIES 4 /* response, adapter->host, high priority */ +#define AAC_ADAP_NORM_RESP_ENTRIES 8 /* response, host->adapter, normal priority */ +#define AAC_ADAP_HIGH_RESP_ENTRIES 4 /* response, host->adapter, high priority */ + +#define AAC_TOTALQ_LENGTH (AAC_HOST_HIGH_CMD_ENTRIES + \ + AAC_HOST_NORM_CMD_ENTRIES + \ + AAC_ADAP_HIGH_CMD_ENTRIES + \ + AAC_ADAP_NORM_CMD_ENTRIES + \ + AAC_HOST_HIGH_RESP_ENTRIES + \ + AAC_HOST_NORM_RESP_ENTRIES + \ + AAC_ADAP_HIGH_RESP_ENTRIES + \ + AAC_ADAP_NORM_RESP_ENTRIES) +#define AAC_QUEUE_COUNT 8 +#define AAC_QUEUE_ALIGN 16 + +struct aac_queue_entry { + u_int32_t aq_fib_size; /* FIB size in bytes */ + u_int32_t aq_fib_addr; /* receiver-space address of the FIB */ +} __attribute__ ((packed)); + +#define AAC_PRODUCER_INDEX 0 +#define AAC_CONSUMER_INDEX 1 + +/* + * Table of queue indices and queues used to communicate with the + * controller. This structure must be aligned to AAC_QUEUE_ALIGN + */ +struct aac_queue_table { + /* queue consumer/producer indexes (layout mandated by adapter) */ + u_int32_t qt_qindex[AAC_QUEUE_COUNT][2]; + + /* queue entry structures (layout mandated by adapter) */ + struct aac_queue_entry qt_HostNormCmdQueue [AAC_HOST_NORM_CMD_ENTRIES]; + struct aac_queue_entry qt_HostHighCmdQueue [AAC_HOST_HIGH_CMD_ENTRIES]; + struct aac_queue_entry qt_AdapNormCmdQueue [AAC_ADAP_NORM_CMD_ENTRIES]; + struct aac_queue_entry qt_AdapHighCmdQueue [AAC_ADAP_HIGH_CMD_ENTRIES]; + struct aac_queue_entry qt_HostNormRespQueue[AAC_HOST_NORM_RESP_ENTRIES]; + struct aac_queue_entry qt_HostHighRespQueue[AAC_HOST_HIGH_RESP_ENTRIES]; + struct aac_queue_entry qt_AdapNormRespQueue[AAC_ADAP_NORM_RESP_ENTRIES]; + struct aac_queue_entry qt_AdapHighRespQueue[AAC_ADAP_HIGH_RESP_ENTRIES]; +} __attribute__ ((packed)); + +/* + * Queue names + * + * Note that we base these at 0 in order to use them as array indices. Adaptec + * used base 1 for some unknown reason, and sorted them in a different order. + */ +#define AAC_HOST_NORM_CMD_QUEUE 0 +#define AAC_HOST_HIGH_CMD_QUEUE 1 +#define AAC_ADAP_NORM_CMD_QUEUE 2 +#define AAC_ADAP_HIGH_CMD_QUEUE 3 +#define AAC_HOST_NORM_RESP_QUEUE 4 +#define AAC_HOST_HIGH_RESP_QUEUE 5 +#define AAC_ADAP_NORM_RESP_QUEUE 6 +#define AAC_ADAP_HIGH_RESP_QUEUE 7 + +/* + * List structure used to chain FIBs (used by the adapter - we hang FIBs off + * our private command structure and don't touch these) + */ +struct aac_fib_list_entry { + struct fib_list_entry *Flink; + struct fib_list_entry *Blink; +} __attribute__ ((packed)); + +/* + * FIB (FSA Interface Block?); this is the datastructure passed between the host + * and adapter. + */ +struct aac_fib_header { + u_int32_t XferState; + u_int16_t Command; + u_int8_t StructType; + u_int8_t Flags; + u_int16_t Size; + u_int16_t SenderSize; + u_int32_t SenderFibAddress; + u_int32_t ReceiverFibAddress; + u_int32_t SenderData; + union { + struct { + u_int32_t ReceiverTimeStart; + u_int32_t ReceiverTimeDone; + } _s; + struct aac_fib_list_entry FibLinks; + } _u; +} __attribute__ ((packed)); + +#define AAC_FIB_DATASIZE (512 - sizeof(struct aac_fib_header)) + +struct aac_fib { + struct aac_fib_header Header; + u_int8_t data[AAC_FIB_DATASIZE]; +} __attribute__ ((packed)); + +/* + * FIB commands + */ +typedef enum { + TestCommandResponse = 1, + TestAdapterCommand = 2, + + /* lowlevel and comm commands */ + LastTestCommand = 100, + ReinitHostNormCommandQueue = 101, + ReinitHostHighCommandQueue = 102, + ReinitHostHighRespQueue = 103, + ReinitHostNormRespQueue = 104, + ReinitAdapNormCommandQueue = 105, + ReinitAdapHighCommandQueue = 107, + ReinitAdapHighRespQueue = 108, + ReinitAdapNormRespQueue = 109, + InterfaceShutdown = 110, + DmaCommandFib = 120, + StartProfile = 121, + TermProfile = 122, + SpeedTest = 123, + TakeABreakPt = 124, + RequestPerfData = 125, + SetInterruptDefTimer= 126, + SetInterruptDefCount= 127, + GetInterruptDefStatus= 128, + LastCommCommand = 129, + + /* filesystem commands */ + NuFileSystem = 300, + UFS = 301, + HostFileSystem = 302, + LastFileSystemCommand = 303, + + /* Container Commands */ + ContainerCommand = 500, + ContainerCommand64 = 501, + + /* Cluster Commands */ + ClusterCommand = 550, + + /* Scsi Port commands (scsi passthrough) */ + ScsiPortCommand = 600, + + /* misc house keeping and generic adapter initiated commands */ + AifRequest = 700, + CheckRevision = 701, + FsaHostShutdown = 702, + RequestAdapterInfo = 703, + IsAdapterPaused = 704, + SendHostTime = 705, + LastMiscCommand = 706 +} AAC_FibCommands; + +/* + * FIB types + */ +#define AAC_FIBTYPE_TFIB 1 +#define AAC_FIBTYPE_TQE 2 +#define AAC_FIBTYPE_TCTPERF 3 + +/* + * FIB transfer state + */ +#define AAC_FIBSTATE_HOSTOWNED (1<<0) /* owned by the host */ +#define AAC_FIBSTATE_ADAPTEROWNED (1<<1) /* owned by the adapter */ +#define AAC_FIBSTATE_INITIALISED (1<<2) /* initialised */ +#define AAC_FIBSTATE_EMPTY (1<<3) /* empty */ +#define AAC_FIBSTATE_FROMPOOL (1<<4) /* allocated from pool */ +#define AAC_FIBSTATE_FROMHOST (1<<5) /* sent from the host */ +#define AAC_FIBSTATE_FROMADAP (1<<6) /* sent from the adapter */ +#define AAC_FIBSTATE_REXPECTED (1<<7) /* response is expected */ +#define AAC_FIBSTATE_RNOTEXPECTED (1<<8) /* response is not expected */ +#define AAC_FIBSTATE_DONEADAP (1<<9) /* processed by the adapter */ +#define AAC_FIBSTATE_DONEHOST (1<<10) /* processed by the host */ +#define AAC_FIBSTATE_HIGH (1<<11) /* high priority */ +#define AAC_FIBSTATE_NORM (1<<12) /* normal priority */ +#define AAC_FIBSTATE_ASYNC (1<<13) +#define AAC_FIBSTATE_ASYNCIO (1<<13) /* to be removed */ +#define AAC_FIBSTATE_PAGEFILEIO (1<<14) /* to be removed */ +#define AAC_FIBSTATE_SHUTDOWN (1<<15) +#define AAC_FIBSTATE_LAZYWRITE (1<<16) /* to be removed */ +#define AAC_FIBSTATE_ADAPMICROFIB (1<<17) +#define AAC_FIBSTATE_BIOSFIB (1<<18) +#define AAC_FIBSTATE_FAST_RESPONSE (1<<19) /* fast response capable */ +#define AAC_FIBSTATE_APIFIB (1<<20) + +/* + * FIB error values + */ +#define AAC_ERROR_NORMAL 0x00 +#define AAC_ERROR_PENDING 0x01 +#define AAC_ERROR_FATAL 0x02 +#define AAC_ERROR_INVALID_QUEUE 0x03 +#define AAC_ERROR_NOENTRIES 0x04 +#define AAC_ERROR_SENDFAILED 0x05 +#define AAC_ERROR_INVALID_QUEUE_PRIORITY 0x06 +#define AAC_ERROR_FIB_ALLOCATION_FAILED 0x07 +#define AAC_ERROR_FIB_DEALLOCATION_FAILED 0x08 + +/* + * Adapter Init Structure: this is passed to the adapter with the + * AAC_MONKER_INITSTRUCT command to point it at our control structures. + */ +struct aac_adapter_init { + u_int32_t InitStructRevision; +#define AAC_INIT_STRUCT_REVISION 3 + u_int32_t MiniPortRevision; + u_int32_t FilesystemRevision; + u_int32_t CommHeaderAddress; + u_int32_t FastIoCommAreaAddress; + u_int32_t AdapterFibsPhysicalAddress; + void *AdapterFibsVirtualAddress; + u_int32_t AdapterFibsSize; + u_int32_t AdapterFibAlign; + u_int32_t PrintfBufferAddress; + u_int32_t PrintfBufferSize; + u_int32_t HostPhysMemPages; + u_int32_t HostElapsedSeconds; +} __attribute__ ((packed)); + +/******************************************************************************** + * Shared data types + */ +/* + * Container types + */ +typedef enum { + CT_NONE = 0, + CT_VOLUME, + CT_MIRROR, + CT_STRIPE, + CT_RAID5, + CT_SSRW, + CT_SSRO, + CT_MORPH, + CT_PASSTHRU, + CT_RAID4, + CT_RAID10, /* stripe of mirror */ + CT_RAID00, /* stripe of stripe */ + CT_VOLUME_OF_MIRRORS, /* volume of mirror */ + CT_PSEUDO_RAID3, /* really raid4 */ +} AAC_FSAVolType; + +/* + * Host-addressable object types + */ +typedef enum { + FT_REG = 1, /* regular file */ + FT_DIR, /* directory */ + FT_BLK, /* "block" device - reserved */ + FT_CHR, /* "character special" device - reserved */ + FT_LNK, /* symbolic link */ + FT_SOCK, /* socket */ + FT_FIFO, /* fifo */ + FT_FILESYS, /* ADAPTEC's "FSA"(tm) filesystem */ + FT_DRIVE, /* physical disk - addressable in scsi by bus/target/lun */ + FT_SLICE, /* virtual disk - raw volume - slice */ + FT_PARTITION, /* FSA partition - carved out of a slice - building block for containers */ + FT_VOLUME, /* Container - Volume Set */ + FT_STRIPE, /* Container - Stripe Set */ + FT_MIRROR, /* Container - Mirror Set */ + FT_RAID5, /* Container - Raid 5 Set */ + FT_DATABASE /* Storage object with "foreign" content manager */ +} AAC_FType; + +/* + * Host-side scatter/gather list for 32-bit commands. + */ +struct aac_sg_entry { + u_int32_t SgAddress; + u_int32_t SgByteCount; +} __attribute__ ((packed)); + +struct aac_sg_table { + u_int32_t SgCount; + struct aac_sg_entry SgEntry[0]; +} __attribute__ ((packed)); + +/* + * Host-side scatter/gather list for 64-bit commands. + */ +struct aac_sg_table64 { + u_int8_t SgCount; + u_int8_t SgSectorsPerPage; + u_int16_t SgByteOffset; + u_int64_t SgEntry[0]; +} __attribute__ ((packed)); + +/* + * Container creation data + */ +struct aac_container_creation { + u_int8_t ViaBuildNumber; + u_int8_t MicroSecond; + u_int8_t Via; /* 1 = FSU, 2 = API, etc. */ + u_int8_t YearsSince1900; + u_int32_t Month:4; /* 1-12 */ + u_int32_t Day:6; /* 1-32 */ + u_int32_t Hour:6; /* 0-23 */ + u_int32_t Minute:6; /* 0-59 */ + u_int32_t Second:6; /* 0-59 */ + u_int64_t ViaAdapterSerialNumber; +} __attribute__ ((packed)); + +/******************************************************************************** + * Revision number handling + */ + +typedef enum { + RevApplication = 1, + RevDkiCli, + RevNetService, + RevApi, + RevFileSysDriver, + RevMiniportDriver, + RevAdapterSW, + RevMonitor, + RevRemoteApi +} RevComponent; + +struct FsaRevision { + union { + struct { + u_int8_t dash; + u_int8_t type; + u_int8_t minor; + u_int8_t major; + } comp; + u_int32_t ul; + } external; + u_int32_t buildNumber; +} __attribute__ ((packed)); + +/******************************************************************************** + * Adapter Information + */ + +typedef enum { + CPU_NTSIM = 1, + CPU_I960, + CPU_ARM, + CPU_SPARC, + CPU_POWERPC, + CPU_ALPHA, + CPU_P7, + CPU_I960_RX, + CPU__last +} AAC_CpuType; + +typedef enum { + CPUI960_JX = 1, + CPUI960_CX, + CPUI960_HX, + CPUI960_RX, + CPUARM_SA110, + CPUARM_xxx, + CPUPPC_603e, + CPUPPC_xxx, + CPUSUBTYPE__last +} AAC_CpuSubType; + +typedef enum { + PLAT_NTSIM = 1, + PLAT_V3ADU, + PLAT_CYCLONE, + PLAT_CYCLONE_HD, + PLAT_BATBOARD, + PLAT_BATBOARD_HD, + PLAT_YOLO, + PLAT_COBRA, + PLAT_ANAHEIM, + PLAT_JALAPENO, + PLAT_QUEENS, + PLAT_JALAPENO_DELL, + PLAT_POBLANO, + PLAT_POBLANO_OPAL, + PLAT_POBLANO_SL0, + PLAT_POBLANO_SL1, + PLAT_POBLANO_SL2, + PLAT_POBLANO_XXX, + PLAT_JALAPENO_P2, + PLAT_HABANERO, + PLAT__last +} AAC_Platform; + +typedef enum { + OEM_FLAVOR_ADAPTEC = 1, + OEM_FLAVOR_DELL, + OEM_FLAVOR_HP, + OEM_FLAVOR_IBM, + OEM_FLAVOR_CPQ, + OEM_FLAVOR_BRAND_X, + OEM_FLAVOR_BRAND_Y, + OEM_FLAVOR_BRAND_Z, + OEM_FLAVOR__last +} AAC_OemFlavor; + +/* + * XXX the aac-2622 with no battery present reports PLATFORM_BAT_OPT_PRESENT + */ +typedef enum +{ + PLATFORM_BAT_REQ_PRESENT = 1, /* BATTERY REQUIRED AND PRESENT */ + PLATFORM_BAT_REQ_NOTPRESENT, /* BATTERY REQUIRED AND NOT PRESENT */ + PLATFORM_BAT_OPT_PRESENT, /* BATTERY OPTIONAL AND PRESENT */ + PLATFORM_BAT_OPT_NOTPRESENT, /* BATTERY OPTIONAL AND NOT PRESENT */ + PLATFORM_BAT_NOT_SUPPORTED /* BATTERY NOT SUPPORTED */ +} AAC_BatteryPlatform; + +/* + * options supported by this board + * there has to be a one to one mapping of these defines and the ones in + * fsaapi.h, search for FSA_SUPPORT_SNAPSHOT + */ +#define AAC_SUPPORTED_SNAPSHOT 0x01 +#define AAC_SUPPORTED_CLUSTERS 0x02 +#define AAC_SUPPORTED_WRITE_CACHE 0x04 +#define AAC_SUPPORTED_64BIT_DATA 0x08 +#define AAC_SUPPORTED_HOST_TIME_FIB 0x10 +#define AAC_SUPPORTED_RAID50 0x20 + +/* + * Structure used to respond to a RequestAdapterInfo fib. + */ +struct aac_adapter_info { + AAC_Platform PlatformBase; /* adapter type */ + AAC_CpuType CpuArchitecture; /* adapter CPU type */ + AAC_CpuSubType CpuVariant; /* adapter CPU subtype */ + u_int32_t ClockSpeed; /* adapter CPU clockspeed */ + u_int32_t ExecutionMem; /* adapter Execution Memory size */ + u_int32_t BufferMem; /* adapter Data Memory */ + u_int32_t TotalMem; /* adapter Total Memory */ + struct FsaRevision KernelRevision; /* adapter Kernel Software Revision */ + struct FsaRevision MonitorRevision; /* adapter Monitor/Diagnostic Software Revision */ + struct FsaRevision HardwareRevision;/* TDB */ + struct FsaRevision BIOSRevision; /* adapter BIOS Revision */ + u_int32_t ClusteringEnabled; + u_int32_t ClusterChannelMask; + u_int64_t SerialNumber; + AAC_BatteryPlatform batteryPlatform; + u_int32_t SupportedOptions; /* supported features of this controller */ + AAC_OemFlavor OemVariant; +} __attribute__ ((packed)); + +/******************************************************************************** + * Monitor/Kernel interface. + */ + +/* + * Synchronous commands to the monitor/kernel. + */ +#define AAC_MONKER_INITSTRUCT 0x05 +#define AAC_MONKER_SYNCFIB 0x0c + +/* + * Adapter Status Register + * + * Phase Staus mailbox is 32bits: + * <31:16> = Phase Status + * <15:0> = Phase + * + * The adapter reports its present state through the phase. Only + * a single phase should be ever be set. Each phase can have multiple + * phase status bits to provide more detailed information about the + * state of the adapter. + */ +#define AAC_SELF_TEST_FAILED 0x00000004 +#define AAC_UP_AND_RUNNING 0x00000080 +#define AAC_KERNEL_PANIC 0x00000100 + +/******************************************************************************** + * Data types relating to control and monitoring of the NVRAM/WriteCache + * subsystem. + */ + +#define AAC_NFILESYS 24 /* maximum number of filesystems */ + +/* + * NVRAM/Write Cache subsystem states + */ +typedef enum { + NVSTATUS_DISABLED = 0, /* present, clean, not being used */ + NVSTATUS_ENABLED, /* present, possibly dirty, ready for use */ + NVSTATUS_ERROR, /* present, dirty, contains dirty data */ + /* for bad/missing device */ + NVSTATUS_BATTERY, /* present, bad or low battery, may contain dirty data */ + /* for bad/missing device */ + NVSTATUS_UNKNOWN +} AAC_NVSTATUS; + +/* + * NVRAM/Write Cache subsystem battery component states + * + */ +typedef enum { + NVBATTSTATUS_NONE = 0, /* battery has no power or is not present */ + NVBATTSTATUS_LOW, /* battery is low on power */ + NVBATTSTATUS_OK, /* battery is okay - normal operation possible only in this state */ + NVBATTSTATUS_RECONDITIONING /* no battery present - reconditioning in process */ +} AAC_NVBATTSTATUS; + +/* + * Battery transition type + */ +typedef enum { + NVBATT_TRANSITION_NONE = 0, /* battery now has no power or is not present */ + NVBATT_TRANSITION_LOW, /* battery is now low on power */ + NVBATT_TRANSITION_OK /* battery is now okay - normal operation possible only in this state */ +} AAC_NVBATT_TRANSITION; + +/* + * NVRAM Info structure returned for NVRAM_GetInfo call + */ +struct aac_nvramdevinfo { + u_int32_t NV_Enabled; /* write caching enabled */ + u_int32_t NV_Error; /* device in error state */ + u_int32_t NV_NDirty; /* count of dirty NVRAM buffers */ + u_int32_t NV_NActive; /* count of NVRAM buffers being written */ +} __attribute__ ((packed)); + +struct aac_nvraminfo { + AAC_NVSTATUS NV_Status; /* nvram subsystem status */ + AAC_NVBATTSTATUS NV_BattStatus; /* battery status */ + u_int32_t NV_Size; /* size of WriteCache NVRAM in bytes */ + u_int32_t NV_BufSize; /* size of NVRAM buffers in bytes */ + u_int32_t NV_NBufs; /* number of NVRAM buffers */ + u_int32_t NV_NDirty; /* count of dirty NVRAM buffers */ + u_int32_t NV_NClean; /* count of clean NVRAM buffers */ + u_int32_t NV_NActive; /* count of NVRAM buffers being written */ + u_int32_t NV_NBrokered; /* count of brokered NVRAM buffers */ + struct aac_nvramdevinfo NV_DevInfo[AAC_NFILESYS]; /* per device info */ + u_int32_t NV_BattNeedsReconditioning; /* boolean */ + u_int32_t NV_TotalSize; /* size of all non-volatile memories in bytes */ +} __attribute__ ((packed)); + +/******************************************************************************** + * Data types relating to adapter-initiated FIBs + * + * Based on types and structures in <aifstruc.h> + */ + +/* + * Progress Reports + */ +typedef enum { + AifJobStsSuccess = 1, + AifJobStsFinished, + AifJobStsAborted, + AifJobStsFailed, + AifJobStsLastReportMarker = 100, /* All before mean last report */ + AifJobStsSuspended, + AifJobStsRunning +} AAC_AifJobStatus; + +typedef enum { + AifJobScsiMin = 1, /* Minimum value for Scsi operation */ + AifJobScsiZero, /* SCSI device clear operation */ + AifJobScsiVerify, /* SCSI device Verify operation NO REPAIR */ + AifJobScsiExercise, /* SCSI device Exercise operation */ + AifJobScsiVerifyRepair, /* SCSI device Verify operation WITH repair */ + AifJobScsiMax = 99, /* Max Scsi value */ + AifJobCtrMin, /* Min Ctr op value */ + AifJobCtrZero, /* Container clear operation */ + AifJobCtrCopy, /* Container copy operation */ + AifJobCtrCreateMirror, /* Container Create Mirror operation */ + AifJobCtrMergeMirror, /* Container Merge Mirror operation */ + AifJobCtrScrubMirror, /* Container Scrub Mirror operation */ + AifJobCtrRebuildRaid5, /* Container Rebuild Raid5 operation */ + AifJobCtrScrubRaid5, /* Container Scrub Raid5 operation */ + AifJobCtrMorph, /* Container morph operation */ + AifJobCtrPartCopy, /* Container Partition copy operation */ + AifJobCtrRebuildMirror, /* Container Rebuild Mirror operation */ + AifJobCtrCrazyCache, /* crazy cache */ + AifJobCtrMax = 199, /* Max Ctr type operation */ + AifJobFsMin, /* Min Fs type operation */ + AifJobFsCreate, /* File System Create operation */ + AifJobFsVerify, /* File System Verify operation */ + AifJobFsExtend, /* File System Extend operation */ + AifJobFsMax = 299, /* Max Fs type operation */ + AifJobApiFormatNTFS, /* Format a drive to NTFS */ + AifJobApiFormatFAT, /* Format a drive to FAT */ + AifJobApiUpdateSnapshot, /* update the read/write half of a snapshot */ + AifJobApiFormatFAT32, /* Format a drive to FAT32 */ + AifJobApiMax = 399, /* Max API type operation */ + AifJobCtlContinuousCtrVerify, /* Adapter operation */ + AifJobCtlMax = 499 /* Max Adapter type operation */ +} AAC_AifJobType; + +struct aac_AifContainers { + u_int32_t src; /* from/master */ + u_int32_t dst; /* to/slave */ +} __attribute__ ((packed)); + +union aac_AifJobClient { + struct aac_AifContainers container; /* For Container and file system progress ops; */ + int32_t scsi_dh; /* For SCSI progress ops */ +}; + +struct aac_AifJobDesc { + u_int32_t jobID; /* DO NOT FILL IN! Will be filled in by AIF */ + AAC_AifJobType type; /* Operation that is being performed */ + union aac_AifJobClient client; /* Details */ +} __attribute__ ((packed)); + +struct aac_AifJobProgressReport { + struct aac_AifJobDesc jd; + AAC_AifJobStatus status; + u_int32_t finalTick; + u_int32_t currentTick; + u_int32_t jobSpecificData1; + u_int32_t jobSpecificData2; +} __attribute__ ((packed)); + +/* + * Event Notification + */ +typedef enum { + /* General application notifies start here */ + AifEnGeneric = 1, /* Generic notification */ + AifEnTaskComplete, /* Task has completed */ + AifEnConfigChange, /* Adapter configuration change occurred */ + AifEnContainerChange, /* Adapter specific container configuration change */ + AifEnDeviceFailure, /* SCSI device failed */ + AifEnMirrorFailover, /* Mirror failover started */ + AifEnContainerEvent, /* Significant container event */ + AifEnFileSystemChange, /* File system changed */ + AifEnConfigPause, /* Container pause event */ + AifEnConfigResume, /* Container resume event */ + AifEnFailoverChange, /* Failover space assignment changed */ + AifEnRAID5RebuildDone, /* RAID5 rebuild finished */ + AifEnEnclosureManagement, /* Enclosure management event */ + AifEnBatteryEvent, /* Significant NV battery event */ + AifEnAddContainer, /* A new container was created. */ + AifEnDeleteContainer, /* A container was deleted. */ + AifEnSMARTEvent, /* SMART Event */ + AifEnBatteryNeedsRecond, /* The battery needs reconditioning */ + AifEnClusterEvent, /* Some cluster event */ + AifEnDiskSetEvent, /* A disk set event occured. */ + AifDriverNotifyStart=199, /* Notifies for host driver go here */ + /* Host driver notifications start here */ + AifDenMorphComplete, /* A morph operation completed */ + AifDenVolumeExtendComplete /* A volume expand operation completed */ +} AAC_AifEventNotifyType; + +struct aac_AifEnsGeneric { + char text[132]; /* Generic text */ +} __attribute__ ((packed)); + +struct aac_AifEnsDeviceFailure { + u_int32_t deviceHandle; /* SCSI device handle */ +} __attribute__ ((packed)); + +struct aac_AifEnsMirrorFailover { + u_int32_t container; /* Container with failed element */ + u_int32_t failedSlice; /* Old slice which failed */ + u_int32_t creatingSlice; /* New slice used for auto-create */ +} __attribute__ ((packed)); + +struct aac_AifEnsContainerChange { + u_int32_t container[2]; /* container that changed, -1 if no container */ +} __attribute__ ((packed)); + +struct aac_AifEnsContainerEvent { + u_int32_t container; /* container number */ + u_int32_t eventType; /* event type */ +} __attribute__ ((packed)); + +struct aac_AifEnsEnclosureEvent { + u_int32_t empID; /* enclosure management processor number */ + u_int32_t unitID; /* unitId, fan id, power supply id, slot id, tempsensor id. */ + u_int32_t eventType; /* event type */ +} __attribute__ ((packed)); + +struct aac_AifEnsBatteryEvent { + AAC_NVBATT_TRANSITION transition_type; /* e.g. from low to ok */ + AAC_NVBATTSTATUS current_state; /* current battery state */ + AAC_NVBATTSTATUS prior_state; /* previous battery state */ +} __attribute__ ((packed)); + +struct aac_AifEnsDiskSetEvent { + u_int32_t eventType; + u_int64_t DsNum; + u_int64_t CreatorId; +} __attribute__ ((packed)); + +typedef enum { + CLUSTER_NULL_EVENT = 0, + CLUSTER_PARTNER_NAME_EVENT, /* change in partner hostname or adaptername from NULL to non-NULL */ + /* (partner's agent may be up) */ + CLUSTER_PARTNER_NULL_NAME_EVENT /* change in partner hostname or adaptername from non-null to NULL */ + /* (partner has rebooted) */ +} AAC_ClusterAifEvent; + +struct aac_AifEnsClusterEvent { + AAC_ClusterAifEvent eventType; +} __attribute__ ((packed)); + +struct aac_AifEventNotify { + AAC_AifEventNotifyType type; + union { + struct aac_AifEnsGeneric EG; + struct aac_AifEnsDeviceFailure EDF; + struct aac_AifEnsMirrorFailover EMF; + struct aac_AifEnsContainerChange ECC; + struct aac_AifEnsContainerEvent ECE; + struct aac_AifEnsEnclosureEvent EEE; + struct aac_AifEnsBatteryEvent EBE; + struct aac_AifEnsDiskSetEvent EDS; +/* struct aac_AifEnsSMARTEvent ES;*/ + struct aac_AifEnsClusterEvent ECLE; + } data; +} __attribute__ ((packed)); + +/* + * Adapter Initiated FIB command structures. Start with the adapter + * initiated FIBs that really come from the adapter, and get responded + * to by the host. + */ +#define AAC_AIF_REPORT_MAX_SIZE 64 + +typedef enum { + AifCmdEventNotify = 1, /* Notify of event */ + AifCmdJobProgress, /* Progress report */ + AifCmdAPIReport, /* Report from other user of API */ + AifCmdDriverNotify, /* Notify host driver of event */ + AifReqJobList = 100, /* Gets back complete job list */ + AifReqJobsForCtr, /* Gets back jobs for specific container */ + AifReqJobsForScsi, /* Gets back jobs for specific SCSI device */ + AifReqJobReport, /* Gets back a specific job report or list of them */ + AifReqTerminateJob, /* Terminates job */ + AifReqSuspendJob, /* Suspends a job */ + AifReqResumeJob, /* Resumes a job */ + AifReqSendAPIReport, /* API generic report requests */ + AifReqAPIJobStart, /* Start a job from the API */ + AifReqAPIJobUpdate, /* Update a job report from the API */ + AifReqAPIJobFinish /* Finish a job from the API */ +} AAC_AifCommand; + +struct aac_aif_command { + AAC_AifCommand command; /* Tell host what type of notify this is */ + u_int32_t seqNumber; /* To allow ordering of reports (if necessary) */ + union { + struct aac_AifEventNotify EN; /* Event notify structure */ + struct aac_AifJobProgressReport PR[1]; /* Progress report */ + u_int8_t AR[AAC_AIF_REPORT_MAX_SIZE]; + } data; +} __attribute__ ((packed)); + +/******************************************************************************** + * Filesystem commands/data + * + * The adapter has a very complex filesystem interface, most of which we ignore. + * (And which seems not to be implemented, anyway.) + */ + +/* + * FSA commands + * (not used?) + */ +typedef enum { + Null = 0, + GetAttributes, + SetAttributes, + Lookup, + ReadLink, + Read, + Write, + Create, + MakeDirectory, + SymbolicLink, + MakeNode, + Removex, + RemoveDirectory, + Rename, + Link, + ReadDirectory, + ReadDirectoryPlus, + FileSystemStatus, + FileSystemInfo, + PathConfigure, + Commit, + Mount, + UnMount, + Newfs, + FsCheck, + FsSync, + SimReadWrite, + SetFileSystemStatus, + BlockRead, + BlockWrite, + NvramIoctl, + FsSyncWait, + ClearArchiveBit, + SetAcl, + GetAcl, + AssignAcl, + FaultInsertion, + CrazyCache +} AAC_FSACommand; + +/* + * Command status values + */ +typedef enum { + ST_OK = 0, + ST_PERM = 1, + ST_NOENT = 2, + ST_IO = 5, + ST_NXIO = 6, + ST_E2BIG = 7, + ST_ACCES = 13, + ST_EXIST = 17, + ST_XDEV = 18, + ST_NODEV = 19, + ST_NOTDIR = 20, + ST_ISDIR = 21, + ST_INVAL = 22, + ST_FBIG = 27, + ST_NOSPC = 28, + ST_ROFS = 30, + ST_MLINK = 31, + ST_WOULDBLOCK = 35, + ST_NAMETOOLONG = 63, + ST_NOTEMPTY = 66, + ST_DQUOT = 69, + ST_STALE = 70, + ST_REMOTE = 71, + ST_BADHANDLE = 10001, + ST_NOT_SYNC = 10002, + ST_BAD_COOKIE = 10003, + ST_NOTSUPP = 10004, + ST_TOOSMALL = 10005, + ST_SERVERFAULT = 10006, + ST_BADTYPE = 10007, + ST_JUKEBOX = 10008, + ST_NOTMOUNTED = 10009, + ST_MAINTMODE = 10010, + ST_STALEACL = 10011 +} AAC_FSAStatus; + +/* + * Volume manager commands + */ +typedef enum _VM_COMMANDS { + VM_Null = 0, + VM_NameServe, + VM_ContainerConfig, + VM_Ioctl, + VM_FilesystemIoctl, + VM_CloseAll, + VM_CtBlockRead, + VM_CtBlockWrite, + VM_SliceBlockRead, /* raw access to configured "storage objects" */ + VM_SliceBlockWrite, + VM_DriveBlockRead, /* raw access to physical devices */ + VM_DriveBlockWrite, + VM_EnclosureMgt, /* enclosure management */ + VM_Unused, /* used to be diskset management */ + VM_CtBlockVerify, + VM_CtPerf, /* performance test */ + VM_CtBlockRead64, + VM_CtBlockWrite64, + VM_CtBlockVerify64, +} AAC_VMCommand; + +/* + * "mountable object" + */ +struct aac_mntobj { + u_int32_t ObjectId; + char FileSystemName[16]; + struct aac_container_creation CreateInfo; + u_int32_t Capacity; + AAC_FSAVolType VolType; + AAC_FType ObjType; + u_int32_t ContentState; +#define FSCS_READONLY 0x0002 /* XXX need more information than this */ + union { + u_int32_t pad[8]; + } ObjExtension; + u_int32_t AlterEgoId; +} __attribute__ ((packed)); + +struct aac_mntinfo { + AAC_VMCommand Command; + AAC_FType MntType; + u_int32_t MntCount; +} __attribute__ ((packed)); + +struct aac_mntinforesponse { + AAC_FSAStatus Status; + AAC_FType MntType; + u_int32_t MntRespCount; + struct aac_mntobj MntTable[1]; +} __attribute__ ((packed)); + +/* + * Container shutdown command. + */ +struct aac_closecommand { + u_int32_t Command; + u_int32_t ComainerId; +} __attribute__ ((packed)); + +/* + * Write 'stability' options. + */ +typedef enum { + CSTABLE = 1, + CUNSTABLE +} AAC_CacheLevel; + +/* + * Commit level response for a write request. + */ +typedef enum { + CMFILE_SYNC_NVRAM = 1, + CMDATA_SYNC_NVRAM, + CMFILE_SYNC, + CMDATA_SYNC, + CMUNSTABLE +} AAC_CommitLevel; + +/* + * Block read/write operations. + * These structures are packed into the 'data' area in the FIB. + */ + +struct aac_blockread { + AAC_VMCommand Command; /* not FSACommand! */ + u_int32_t ContainerId; + u_int32_t BlockNumber; + u_int32_t ByteCount; + struct aac_sg_table SgMap; /* variable size */ +} __attribute__ ((packed)); + +struct aac_blockread_response { + AAC_FSAStatus Status; + u_int32_t ByteCount; +} __attribute__ ((packed)); + +struct aac_blockwrite { + AAC_VMCommand Command; /* not FSACommand! */ + u_int32_t ContainerId; + u_int32_t BlockNumber; + u_int32_t ByteCount; + AAC_CacheLevel Stable; + struct aac_sg_table SgMap; /* variable size */ +} __attribute__ ((packed)); + +struct aac_blockwrite_response { + AAC_FSAStatus Status; + u_int32_t ByteCount; + AAC_CommitLevel Committed; +} __attribute__ ((packed)); + +/* + * Container shutdown command. + */ +struct aac_close_command { + AAC_VMCommand Command; + u_int32_t ContainerId; +}; + +/******************************************************************************** + * Register definitions for the Adaptec AAC-364 'Jalapeno I/II' adapters, based + * on the SA110 'StrongArm'. + */ + +#define AAC_SA_DOORBELL0_CLEAR 0x98 /* doorbell 0 (adapter->host) */ +#define AAC_SA_DOORBELL0_SET 0x9c +#define AAC_SA_DOORBELL0 0x9c +#define AAC_SA_MASK0_CLEAR 0xa0 +#define AAC_SA_MASK0_SET 0xa4 + +#define AAC_SA_DOORBELL1_CLEAR 0x9a /* doorbell 1 (host->adapter) */ +#define AAC_SA_DOORBELL1_SET 0x9e +#define AAC_SA_MASK1_CLEAR 0xa2 +#define AAC_SA_MASK1_SET 0xa6 + +#define AAC_SA_MAILBOX 0xa8 /* mailbox (20 bytes) */ +#define AAC_SA_FWSTATUS 0xc4 + +/******************************************************************************** + * Register definitions for the Adaptec 'Pablano' adapters, based on the i960Rx, + * and other related adapters. + */ + +#define AAC_RX_IDBR 0x20 /* inbound doorbell register */ +#define AAC_RX_IISR 0x24 /* inbound interrupt mask register */ +#define AAC_RX_IIMR 0x28 /* inbound interrupt status register */ +#define AAC_RX_ODBR 0x2c /* outbound doorbell register */ +#define AAC_RX_OISR 0x30 /* outbound interrupt mask register */ +#define AAC_RX_OIMR 0x34 /* outbound interrupt status register */ + +#define AAC_RX_MAILBOX 0x50 /* mailbox (20 bytes) */ +#define AAC_RX_FWSTATUS 0x6c + +/******************************************************************************** + * Common bit definitions for the doorbell registers. + */ + +/* + * Status bits in the doorbell registers. + */ +#define AAC_DB_SYNC_COMMAND (1<<0) /* send/completed synchronous FIB */ +#define AAC_DB_COMMAND_READY (1<<1) /* posted one or more commands */ +#define AAC_DB_RESPONSE_READY (1<<2) /* one or more commands complete */ +#define AAC_DB_COMMAND_NOT_FULL (1<<3) /* command queue not full */ +#define AAC_DB_RESPONSE_NOT_FULL (1<<4) /* response queue not full */ + +/* + * The adapter can request the host print a message by setting the + * DB_PRINTF flag in DOORBELL0. The driver responds by collecting the + * message from the printf buffer, clearing the DB_PRINTF flag in + * DOORBELL0 and setting it in DOORBELL1. + * (ODBR and IDBR respectively for the i960Rx adapters) + */ +#define AAC_DB_PRINTF (1<<5) /* adapter requests host printf */ + +/* + * Mask containing the interrupt bits we care about. We don't anticipate (or want) + * interrupts not in this mask. + */ +#define AAC_DB_INTERRUPTS (AAC_DB_COMMAND_READY | AAC_DB_RESPONSE_READY | AAC_DB_PRINTF) diff --git a/sys/dev/aac/aacvar.h b/sys/dev/aac/aacvar.h new file mode 100644 index 000000000000..68d21725c5a4 --- /dev/null +++ b/sys/dev/aac/aacvar.h @@ -0,0 +1,451 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/******************************************************************************** + ******************************************************************************** + Driver Parameter Definitions + ******************************************************************************** + ********************************************************************************/ + +/* + * The firmware interface allows for a 16-bit s/g list length. We limit + * ourselves to a reasonable maximum and ensure alignment. + */ +#define AAC_MAXSGENTRIES 64 /* max S/G entries, limit 65535 */ + +/* + * We allocate a small set of FIBs for the adapter to use to send us messages. + */ +#define AAC_ADAPTER_FIBS 8 + +/* + * FIBs are allocated in clusters as we need them; each cluster must be physically + * contiguous. Set the number of FIBs to try to allocate in a cluster. + * Setting this value too high may result in FIBs not being available in conditions + * of high load with fragmented physical memory. The value must be a multiple of + * (PAGE_SIZE / 512). + */ +#define AAC_CLUSTER_COUNT 64 + +/* + * The controller reports status events in AIFs. We hang on to a number of these + * in order to pass them out to user-space management tools. + */ +#define AAC_AIFQ_LENGTH 64 + +/* + * Firmware messages are passed in the printf buffer. + */ +#define AAC_PRINTF_BUFSIZE 256 + +/* + * We wait this many seconds for the adapter to come ready if it is still booting + */ +#define AAC_BOOT_TIMEOUT (3 * 60) + +/* + * Timeout for immediate commands. + */ +#define AAC_IMMEDIATE_TIMEOUT 30 + +/* + * Character device major numbers. + */ +#define AAC_DISK_MAJOR 200 + +/******************************************************************************** + ******************************************************************************** + Driver Variable Definitions + ******************************************************************************** + ********************************************************************************/ + +#if __FreeBSD_version >= 500005 +# include <sys/taskqueue.h> +#endif + +/* + * Per-container data structure + */ +struct aac_container +{ + struct aac_mntobj co_mntobj; + device_t co_disk; +}; + +/* + * Per-disk structure + */ +struct aac_disk +{ + device_t ad_dev; + dev_t ad_dev_t; + struct aac_softc *ad_controller; + struct aac_container *ad_container; + struct disk ad_disk; + struct devstat ad_stats; + struct disklabel ad_label; + int ad_flags; +#define AAC_DISK_OPEN (1<<0) + int ad_cylinders; + int ad_heads; + int ad_sectors; + u_int32_t ad_size; +}; + +/* + * Per-command control structure. + */ +struct aac_command +{ + TAILQ_ENTRY(aac_command) cm_link; /* list linkage */ + + struct aac_softc *cm_sc; /* controller that owns us */ + + struct aac_fib *cm_fib; /* FIB associated with this command */ + u_int32_t cm_fibphys; /* bus address of the FIB */ + struct bio *cm_data; /* pointer to data in kernel space */ + u_int32_t cm_datalen; /* data length */ + bus_dmamap_t cm_datamap; /* DMA map for bio data */ + struct aac_sg_table *cm_sgtable; /* pointer to s/g table in command */ + + int cm_flags; +#define AAC_CMD_MAPPED (1<<0) /* command has had its data mapped */ +#define AAC_CMD_DATAIN (1<<1) /* command involves data moving from controller to host */ +#define AAC_CMD_DATAOUT (1<<2) /* command involves data moving from host to controller */ +#define AAC_CMD_COMPLETED (1<<3) /* command has been completed */ + + void (* cm_complete)(struct aac_command *cm); + void *cm_private; +}; + +/* + * Command/command packet cluster. + * + * Due to the difficulty of using the zone allocator to create a new + * zone from within a module, we use our own clustering to reduce + * memory wastage due to allocating lots of these small structures. + */ +struct aac_command_cluster +{ + TAILQ_ENTRY(aac_command_cluster) cmc_link; + struct aac_fib *cmc_fibs; + bus_dmamap_t cmc_fibmap; + u_int32_t cmc_fibphys; + struct aac_command cmc_command[AAC_CLUSTER_COUNT]; +}; + +/* + * We gather a number of adapter-visible items into a single structure. + * + * The ordering of this strucure may be important; we copy the Linux driver: + * + * Adapter FIBs + * Init struct + * Queue headers (Comm Area) + * Printf buffer + * + * In addition, we add: + * Sync Fib + */ +struct aac_common { + /* fibs for the controller to send us messages */ + struct aac_fib ac_fibs[AAC_ADAPTER_FIBS]; + + /* the init structure */ + struct aac_adapter_init ac_init; + + /* arena within which the queue structures are kept */ + u_int8_t ac_qbuf[sizeof(struct aac_queue_table) + AAC_QUEUE_ALIGN]; + + /* buffer for text messages from the controller */ + char ac_printf[AAC_PRINTF_BUFSIZE]; + + /* fib for synchronous commands */ + struct aac_fib ac_sync_fib; +}; + +/* + * Interface operations + */ +struct aac_interface +{ + int (* aif_get_fwstatus)(struct aac_softc *sc); + void (* aif_qnotify)(struct aac_softc *sc, int qbit); + int (* aif_get_istatus)(struct aac_softc *sc); + void (* aif_set_istatus)(struct aac_softc *sc, int mask); + void (* aif_set_mailbox)(struct aac_softc *sc, u_int32_t command, + u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3); + int (* aif_get_mailboxstatus)(struct aac_softc *sc); + void (* aif_set_interrupts)(struct aac_softc *sc, int enable); +}; +extern struct aac_interface aac_rx_interface; +extern struct aac_interface aac_sa_interface; + +#define AAC_GET_FWSTATUS(sc) ((sc)->aac_if.aif_get_fwstatus((sc))) +#define AAC_QNOTIFY(sc, qbit) ((sc)->aac_if.aif_qnotify((sc), (qbit))) +#define AAC_GET_ISTATUS(sc) ((sc)->aac_if.aif_get_istatus((sc))) +#define AAC_CLEAR_ISTATUS(sc, mask) ((sc)->aac_if.aif_set_istatus((sc), (mask))) +#define AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3) \ + ((sc)->aac_if.aif_set_mailbox((sc), (command), (arg0), (arg1), (arg2), (arg3))) +#define AAC_GET_MAILBOXSTATUS(sc) ((sc)->aac_if.aif_get_mailboxstatus((sc))) +#define AAC_MASK_INTERRUPTS(sc) ((sc)->aac_if.aif_set_interrupts((sc), 0)) +#define AAC_UNMASK_INTERRUPTS(sc) ((sc)->aac_if.aif_set_interrupts((sc), 1)) + +#define AAC_SETREG4(sc, reg, val) bus_space_write_4(sc->aac_btag, sc->aac_bhandle, reg, val) +#define AAC_GETREG4(sc, reg) bus_space_read_4 (sc->aac_btag, sc->aac_bhandle, reg) +#define AAC_SETREG2(sc, reg, val) bus_space_write_2(sc->aac_btag, sc->aac_bhandle, reg, val) +#define AAC_GETREG2(sc, reg) bus_space_read_2 (sc->aac_btag, sc->aac_bhandle, reg) +#define AAC_SETREG1(sc, reg, val) bus_space_write_1(sc->aac_btag, sc->aac_bhandle, reg, val) +#define AAC_GETREG1(sc, reg) bus_space_read_1 (sc->aac_btag, sc->aac_bhandle, reg) + +/* + * Per-controller structure. + */ +struct aac_softc +{ + /* bus connections */ + device_t aac_dev; + struct resource *aac_regs_resource; /* register interface window */ + int aac_regs_rid; /* resource ID */ + bus_space_handle_t aac_bhandle; /* bus space handle */ + bus_space_tag_t aac_btag; /* bus space tag */ + bus_dma_tag_t aac_parent_dmat; /* parent DMA tag */ + bus_dma_tag_t aac_buffer_dmat; /* data buffer/command DMA tag */ + struct resource *aac_irq; /* interrupt */ + int aac_irq_rid; + void *aac_intr; /* interrupt handle */ + + /* controller features, limits and status */ + int aac_state; +#define AAC_STATE_SUSPEND (1<<0) +#define AAC_STATE_OPEN (1<<1) +#define AAC_STATE_INTERRUPTS_ON (1<<2) +#define AAC_STATE_AIF_SLEEPER (1<<3) + struct FsaRevision aac_revision; + + /* controller hardware interface */ + int aac_hwif; +#define AAC_HWIF_I960RX 0 +#define AAC_HWIF_STRONGARM 1 + bus_dma_tag_t aac_common_dmat; /* common structure DMA tag */ + bus_dmamap_t aac_common_dmamap; /* common structure DMA map */ + struct aac_common *aac_common; + u_int32_t aac_common_busaddr; + struct aac_interface aac_if; + + /* command/fib resources */ + TAILQ_HEAD(,aac_command_cluster) aac_clusters; /* command memory blocks */ + bus_dma_tag_t aac_fib_dmat; /* DMA tag for allocating FIBs */ + + /* command management */ + TAILQ_HEAD(,aac_command) aac_freecmds; /* command structures available for reuse */ + TAILQ_HEAD(,aac_command) aac_ready; /* commands on hold for controller resources */ + TAILQ_HEAD(,aac_command) aac_completed; /* commands which have been returned by the controller */ + struct bio_queue_head aac_bioq; + struct aac_queue_table *aac_queues; + struct aac_queue_entry *aac_qentries[AAC_QUEUE_COUNT]; + + /* connected containters */ + struct aac_container aac_container[AAC_MAX_CONTAINERS]; + + /* delayed activity infrastructure */ +#if __FreeBSD_version >= 500005 + struct task aac_task_complete; /* deferred-completion task */ +#endif + struct intr_config_hook aac_ich; + + /* management interface */ + dev_t aac_dev_t; + struct aac_aif_command aac_aifq[AAC_AIFQ_LENGTH]; + int aac_aifq_head; + int aac_aifq_tail; +}; + + +/* + * Public functions + */ +extern void aac_free(struct aac_softc *sc); +extern int aac_attach(struct aac_softc *sc); +extern int aac_detach(device_t dev); +extern int aac_shutdown(device_t dev); +extern int aac_suspend(device_t dev); +extern int aac_resume(device_t dev); +extern void aac_intr(void *arg); +extern devclass_t aac_devclass; +extern void aac_submit_bio(struct bio *bp); +extern void aac_complete_bio(struct bio *bp); + +/* + * Debugging levels: + * 0 - quiet, only emit warnings + * 1 - noisy, emit major function points and things done + * 2 - extremely noisy, emit trace items in loops, etc. + */ +#ifdef AAC_DEBUG +#define debug(level, fmt, args...) do { if (level <= AAC_DEBUG) printf("%s: " fmt "\n", __FUNCTION__ , ##args); } while(0) +#define debug_called(level) do { if (level <= AAC_DEBUG) printf(__FUNCTION__ ": called\n"); } while(0) + +extern void aac_print_queues(struct aac_softc *sc); +extern void aac_panic(struct aac_softc *sc, char *reason); +extern void aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, char *caller); +extern void aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif); + +#define AAC_PRINT_FIB(sc, fib) aac_print_fib(sc, fib, __FUNCTION__) + +#else +#define debug(level, fmt, args...) +#define debug_called(level) + +#define aac_print_queues(sc) +#define aac_panic(sc, reason) +#define aac_print_aif(sc, aif) + +#define AAC_PRINT_FIB(sc, fib) +#endif + +struct aac_code_lookup { + char *string; + u_int32_t code; +}; + +/* + * Borrowed from <struct.h> + */ +/* Offset of the field in the structure. */ +#define fldoff(name, field) \ + ((int)&(((struct name *)0)->field)) + +/******************************************************************************** + * Queue primitives + * + * These are broken out individually to make statistics gathering easier. + */ + +static __inline void +aac_enqueue_ready(struct aac_command *cm) +{ + int s; + + s = splbio(); + TAILQ_INSERT_TAIL(&cm->cm_sc->aac_ready, cm, cm_link); + splx(s); +} + +static __inline void +aac_requeue_ready(struct aac_command *cm) +{ + int s; + + s = splbio(); + TAILQ_INSERT_HEAD(&cm->cm_sc->aac_ready, cm, cm_link); + splx(s); +} + +static __inline struct aac_command * +aac_dequeue_ready(struct aac_softc *sc) +{ + struct aac_command *cm; + int s; + + s = splbio(); + if ((cm = TAILQ_FIRST(&sc->aac_ready)) != NULL) + TAILQ_REMOVE(&sc->aac_ready, cm, cm_link); + splx(s); + return(cm); +} + +static __inline void +aac_enqueue_completed(struct aac_command *cm) +{ + int s; + + s = splbio(); + TAILQ_INSERT_TAIL(&cm->cm_sc->aac_completed, cm, cm_link); + splx(s); +} + +static __inline struct aac_command * +aac_dequeue_completed(struct aac_softc *sc) +{ + struct aac_command *cm; + int s; + + s = splbio(); + if ((cm = TAILQ_FIRST(&sc->aac_completed)) != NULL) + TAILQ_REMOVE(&sc->aac_completed, cm, cm_link); + splx(s); + return(cm); +} + +static __inline void +aac_enqueue_free(struct aac_command *cm) +{ + int s; + + s = splbio(); + TAILQ_INSERT_HEAD(&cm->cm_sc->aac_freecmds, cm, cm_link); + splx(s); +} + +static __inline struct aac_command * +aac_dequeue_free(struct aac_softc *sc) +{ + struct aac_command *cm; + int s; + + s = splbio(); + if ((cm = TAILQ_FIRST(&sc->aac_freecmds)) != NULL) + TAILQ_REMOVE(&sc->aac_freecmds, cm, cm_link); + splx(s); + return(cm); +} + +static __inline void +aac_enqueue_cluster(struct aac_softc *sc, struct aac_command_cluster *cmc) +{ + int s; + + s = splbio(); + TAILQ_INSERT_HEAD(&sc->aac_clusters, cmc, cmc_link); + splx(s); +} + +static __inline struct aac_command_cluster * +aac_dequeue_cluster(struct aac_softc *sc) +{ + struct aac_command_cluster *cmc; + int s; + + s = splbio(); + if ((cmc = TAILQ_FIRST(&sc->aac_clusters)) != NULL) + TAILQ_REMOVE(&sc->aac_clusters, cmc, cmc_link); + splx(s); + return(cmc); +} diff --git a/sys/i386/conf/GENERIC b/sys/i386/conf/GENERIC index 215ee664bbac..7cc95b221d20 100644 --- a/sys/i386/conf/GENERIC +++ b/sys/i386/conf/GENERIC @@ -112,6 +112,7 @@ device cd # CD device pass # Passthrough device (direct SCSI access) # RAID controllers +device aac # Adaptec FSA RAID device ida # Compaq Smart RAID device amr # AMI MegaRAID device mlx # Mylex DAC960 family diff --git a/sys/i386/conf/NOTES b/sys/i386/conf/NOTES index 2ebc8c70d044..8e690c1a87d4 100644 --- a/sys/i386/conf/NOTES +++ b/sys/i386/conf/NOTES @@ -1331,6 +1331,11 @@ options DPT_ALLOW_MEMIO device mly # +# Adaptec FSA RAID controllers, including integrated DELL controllers, +# the Dell PERC 2/QC and the HP NetRAID-4M +device aac + +# # Compaq Smart RAID, Mylex DAC960 and AMI MegaRAID controllers. Only # one entry is needed; the code will find and configure all supported # controllers. diff --git a/sys/modules/Makefile b/sys/modules/Makefile index 1b9118c0548b..8b8806a3c6e7 100644 --- a/sys/modules/Makefile +++ b/sys/modules/Makefile @@ -17,7 +17,7 @@ SUBDIR= 3dfx accf_data accf_http agp aha amr an aue \ # XXX some of these can move to the general case when de-i386'ed .if ${MACHINE_ARCH} == "i386" -SUBDIR+=asr bktr coff fpu gnufpu ibcs2 linprocfs linux mly splash streams \ +SUBDIR+=aac asr bktr coff fpu gnufpu ibcs2 linprocfs linux mly splash streams \ svr4 vesa wi .endif diff --git a/sys/modules/aac/Makefile b/sys/modules/aac/Makefile new file mode 100644 index 000000000000..6a2baefc6e7b --- /dev/null +++ b/sys/modules/aac/Makefile @@ -0,0 +1,13 @@ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../dev/aac +KMOD = aac +SRCS = aac.c aac_pci.c aac_disk.c +SRCS += device_if.h bus_if.h pci_if.h + +CFLAGS+= -DAAC_COMPAT_LINUX + +#CFLAGS+= -DAAC_DEBUG=2 +#SRCS += aac_debug.c + +.include <bsd.kmod.mk> diff --git a/sys/sys/aac_ioctl.h b/sys/sys/aac_ioctl.h new file mode 100644 index 000000000000..354c0aa5cddc --- /dev/null +++ b/sys/sys/aac_ioctl.h @@ -0,0 +1,78 @@ +/*- + * Copyright (c) 2000 Michael Smith + * Copyright (c) 2000 Scott Long + * Copyright (c) 2000 BSDi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifdef AAC_COMPAT_LINUX + +/* + * Ioctl commands likely to be submitted from a Linux management application. + * These bit encodings are actually descended from Windows NT. Ick. + */ + +#define CTL_CODE(devType, func, meth, acc) (((devType) << 16) | ((acc) << 14) | ((func) << 2) | (meth)) +#define METHOD_BUFFERED 0 +#define METHOD_IN_DIRECT 1 +#define METHOD_OUT_DIRECT 2 +#define METHOD_NEITHER 3 +#define FILE_ANY_ACCESS 0 +#define FILE_READ_ACCESS ( 0x0001 ) +#define FILE_WRITE_ACCESS ( 0x0002 ) +#define FILE_DEVICE_CONTROLLER 0x00000004 + +#define FSACTL_SENDFIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2050, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_AIF_THREAD CTL_CODE(FILE_DEVICE_CONTROLLER, 2127, METHOD_NEITHER, FILE_ANY_ACCESS) +#define FSACTL_OPEN_GET_ADAPTER_FIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2100, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_GET_NEXT_ADAPTER_FIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2101, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_CLOSE_GET_ADAPTER_FIB CTL_CODE(FILE_DEVICE_CONTROLLER, 2102, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define FSACTL_MINIPORT_REV_CHECK CTL_CODE(FILE_DEVICE_CONTROLLER, 2107, METHOD_BUFFERED, FILE_ANY_ACCESS) + +/* + * Support for faking the "miniport" version. + */ +struct aac_rev_check { + RevComponent callingComponent; + struct FsaRevision callingRevision; +}; + +struct aac_rev_check_resp { + int possiblyCompatible; + struct FsaRevision adapterSWRevision; +}; + +/* + * Context passed in by a consumer looking to collect an AIF. + */ +#define AAC_AIF_SILLYMAGIC 0xdeadbeef +struct get_adapter_fib_ioctl { + u_int32_t AdapterFibContext; + int Wait; + caddr_t AifFib; +}; + +#endif |