mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-04 09:09:56 +00:00
Code Issues Releases Activity

This is the initial import of a new driver for the current family of

Browse Source 
PCI:SCSI RAID controllers from Mylex.
This commit is contained in:
Mike Smith 2000-08-23 03:22:41 +00:00
parent c1e6727a77
commit e07acca5f0
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=64987
9 changed files with 4857 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sys/conf/files
View File

@ -197,6 +197,9 @@ dev/mii/miibus_if.m optional miibus
dev/mlx/mlx.c optional mlx
dev/mlx/mlx_disk.c optional mlx
dev/mlx/mlx_pci.c optional mlx
dev/mly/mly.c optional mly
dev/mly/mly_cam.c optional mly
dev/mly/mly_pci.c optional mly
dev/musycc/musycc.c optional musycc
dev/nulldev/nulldev.c standard
dev/pccard/card_if.m optional card

1711
sys/dev/mly/mly.c Normal file
View File

File diff suppressed because it is too large Load Diff

513
sys/dev/mly/mly_cam.c Normal file
View File

@ -0,0 +1,513 @@
/*-
* 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$
*/
/*
* CAM interface for FreeBSD
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/devicestat.h>
#include <cam/cam.h>
#include <cam/cam_ccb.h>
#include <cam/cam_periph.h>
#include <cam/cam_sim.h>
#include <cam/cam_xpt_sim.h>
#include <cam/scsi/scsi_all.h>
#include <machine/resource.h>
#include <machine/bus.h>
#include <dev/mly/mlyreg.h>
#include <dev/mly/mlyvar.h>
#include <dev/mly/mly_tables.h>
static void mly_cam_poll(struct cam_sim *sim);
static void mly_cam_action(struct cam_sim *sim, union ccb *ccb);
static void mly_cam_complete(struct mly_command *mc);
static struct cam_periph *mly_find_periph(struct mly_softc *sc, int bus, int target);
/********************************************************************************
* CAM-specific queue primitives
*/
static __inline void
mly_enqueue_ccb(struct mly_softc *sc, union ccb *ccb)
{
int s;
s = splcam();
TAILQ_INSERT_TAIL(&sc->mly_cam_ccbq, &ccb->ccb_h, sim_links.tqe);
splx(s);
}
static __inline void
mly_requeue_ccb(struct mly_softc *sc, union ccb *ccb)
{
int s;
s = splcam();
TAILQ_INSERT_HEAD(&sc->mly_cam_ccbq, &ccb->ccb_h, sim_links.tqe);
splx(s);
}
static __inline union ccb *
mly_dequeue_ccb(struct mly_softc *sc)
{
union ccb *ccb;
int s;
s = splcam();
if ((ccb = (union ccb *)TAILQ_FIRST(&sc->mly_cam_ccbq)) != NULL)
TAILQ_REMOVE(&sc->mly_cam_ccbq, &ccb->ccb_h, sim_links.tqe);
splx(s);
return(ccb);
}
/********************************************************************************
* space-fill a character string
*/
static __inline void
padstr(char *targ, char *src, int len)
{
while (len-- > 0) {
if (*src != 0) {
*targ++ = *src++;
} else {
*targ++ = ' ';
}
}
}
/********************************************************************************
* Attach the real and virtual SCSI busses to CAM
*/
int
mly_cam_attach(struct mly_softc *sc)
{
struct cam_devq *devq;
int chn, nchn;
debug_called(1);
/* initialise the CCB queue */
TAILQ_INIT(&sc->mly_cam_ccbq);
/*
* Allocate a devq for all our channels combined.
*/
if ((devq = cam_simq_alloc(sc->mly_controllerinfo->maximum_parallel_commands)) == NULL) {
mly_printf(sc, "can't allocate CAM SIM\n");
return(ENOMEM);
}
/*
* Iterate over channels, registering them with CAM.
*/
nchn = sc->mly_controllerinfo->physical_channels_present +
sc->mly_controllerinfo->virtual_channels_present;
for (chn = 0; chn < nchn; chn++) {
/* allocate a sim */
if ((sc->mly_cam_sim[chn] = cam_sim_alloc(mly_cam_action,
mly_cam_poll,
"mly",
sc,
device_get_unit(sc->mly_dev),
1,
sc->mly_controllerinfo->maximum_parallel_commands,
devq)) == NULL) {
cam_simq_free(devq);
mly_printf(sc, "CAM SIM attach failed\n");
return(ENOMEM);
}
/* register the bus ID so we can get it later */
if (xpt_bus_register(sc->mly_cam_sim[chn], chn)) {
mly_printf(sc, "CAM XPT bus registration failed\n");
return(ENXIO);
}
debug(1, "registered sim %p bus %d", sc->mly_cam_sim[chn], chn);
}
return(0);
}
/********************************************************************************
* Detach from CAM
*/
void
mly_cam_detach(struct mly_softc *sc)
{
int chn, nchn, first;
debug_called(1);
nchn = sc->mly_controllerinfo->physical_channels_present +
sc->mly_controllerinfo->virtual_channels_present;
/*
* Iterate over channels, deregistering as we go.
*/
nchn = sc->mly_controllerinfo->physical_channels_present +
sc->mly_controllerinfo->virtual_channels_present;
for (chn = 0, first = 1; chn < nchn; chn++) {
/*
* If a sim was registered for this channel, free it.
*/
if (sc->mly_cam_sim[chn] != NULL) {
debug(1, "deregister bus %d", chn);
xpt_bus_deregister(cam_sim_path(sc->mly_cam_sim[chn]));
debug(1, "free sim for channel %d (%sfree queue)", chn, first ? "" : "don't ");
cam_sim_free(sc->mly_cam_sim[chn], first ? TRUE : FALSE);
first = 0;
}
}
}
/********************************************************************************
* Handle an action requested by CAM
*/
static void
mly_cam_action(struct cam_sim *sim, union ccb *ccb)
{
struct mly_softc *sc = cam_sim_softc(sim);
debug_called(2);
switch (ccb->ccb_h.func_code) {
/* perform SCSI I/O */
case XPT_SCSI_IO:
{
struct ccb_scsiio *csio = &ccb->csio;
int bus, target;
bus = cam_sim_bus(sim);
target = csio->ccb_h.target_id;
debug(2, "XPT_SCSI_IO %d:%d:%d", bus, target, ccb->ccb_h.target_lun);
/* check for I/O attempt to a protected device */
if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_PROTECTED) {
debug(2, " device protected");
csio->ccb_h.status = CAM_REQ_CMP_ERR;
}
/* check for I/O attempt to nonexistent device */
if (!(sc->mly_btl[bus][target].mb_flags & (MLY_BTL_LOGICAL | MLY_BTL_PHYSICAL))) {
debug(2, " device does not exist");
csio->ccb_h.status = CAM_REQ_CMP_ERR;
}
/* XXX increase if/when we support large SCSI commands */
if (csio->cdb_len > MLY_CMD_SCSI_SMALL_CDB) {
debug(2, " command too large (%d > %d)", csio->cdb_len, MLY_CMD_SCSI_SMALL_CDB);
csio->ccb_h.status = CAM_REQ_CMP_ERR;
}
/* check that the CDB pointer is not to a physical address */
if ((csio->ccb_h.flags & CAM_CDB_POINTER) && (csio->ccb_h.flags & CAM_CDB_PHYS)) {
debug(2, " CDB pointer is to physical address");
csio->ccb_h.status = CAM_REQ_CMP_ERR;
}
/* if there is data transfer, it must be to/from a virtual address */
if ((csio->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
if (csio->ccb_h.flags & CAM_DATA_PHYS) { /* we can't map it */
debug(2, " data pointer is to physical address");
csio->ccb_h.status = CAM_REQ_CMP_ERR;
}
if (csio->ccb_h.flags & CAM_SCATTER_VALID) { /* we want to do the s/g setup */
debug(2, " data has premature s/g setup");
csio->ccb_h.status = CAM_REQ_CMP_ERR;
}
}
/* abandon aborted ccbs or those that have failed validation */
if ((csio->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) {
debug(2, "abandoning CCB due to abort/validation failure");
break;
}
/* save the channel number in the ccb */
csio->ccb_h.sim_priv.entries[0].field = bus;
/* enqueue the ccb and start I/O */
mly_enqueue_ccb(sc, ccb);
mly_startio(sc);
return;
}
/* perform geometry calculations */
case XPT_CALC_GEOMETRY:
{
struct ccb_calc_geometry *ccg = &ccb->ccg;
u_int32_t secs_per_cylinder;
debug(2, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
if (sc->mly_controllerparam->bios_geometry == MLY_BIOSGEOM_8G) {
ccg->heads = 255;
ccg->secs_per_track = 63;
} else { /* MLY_BIOSGEOM_2G */
ccg->heads = 128;
ccg->secs_per_track = 32;
}
secs_per_cylinder = ccg->heads * ccg->secs_per_track;
ccg->cylinders = ccg->volume_size / secs_per_cylinder;
ccb->ccb_h.status = CAM_REQ_CMP;
break;
}
/* handle path attribute inquiry */
case XPT_PATH_INQ:
{
struct ccb_pathinq *cpi = &ccb->cpi;
debug(2, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
cpi->version_num = 1;
cpi->hba_inquiry = PI_TAG_ABLE; /* XXX extra flags for physical channels? */
cpi->target_sprt = 0;
cpi->hba_misc = 0;
cpi->max_target = MLY_MAX_TARGETS - 1;
cpi->max_lun = MLY_MAX_LUNS - 1;
cpi->initiator_id = sc->mly_controllerparam->initiator_id;
strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
strncpy(cpi->hba_vid, "BSDi", HBA_IDLEN);
strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
cpi->unit_number = cam_sim_unit(sim);
cpi->bus_id = cam_sim_bus(sim);
cpi->base_transfer_speed = 132 * 1024; /* XXX what to set this to? */
ccb->ccb_h.status = CAM_REQ_CMP;
break;
}
default: /* we can't do this */
debug(2, "unspported func_code = 0x%x", ccb->ccb_h.func_code);
ccb->ccb_h.status = CAM_REQ_INVALID;
break;
}
xpt_done(ccb);
}
/********************************************************************************
* Check for possibly-completed commands.
*/
static void
mly_cam_poll(struct cam_sim *sim)
{
struct mly_softc *sc = cam_sim_softc(sim);
debug_called(2);
mly_done(sc);
}
/********************************************************************************
* Pull a CCB off the work queue and turn it into a command.
*/
int
mly_cam_command(struct mly_softc *sc, struct mly_command **mcp)
{
struct mly_command *mc;
struct mly_command_scsi_small *ss;
struct ccb_scsiio *csio;
int error;
debug_called(2);
error = 0;
mc = NULL;
csio = NULL;
/* check for a CCB */
if (!(csio = (struct ccb_scsiio *)mly_dequeue_ccb(sc)))
goto out;
/* get a command to back it */
if (mly_alloc_command(sc, &mc)) {
error = ENOMEM;
goto out;
}
/* build the command */
MLY_CMD_SETSTATE(mc, MLY_CMD_SETUP);
mc->mc_data = csio->data_ptr;
mc->mc_length = csio->dxfer_len;
mc->mc_complete = mly_cam_complete;
mc->mc_private = csio;
/* build the packet for the controller */
ss = &mc->mc_packet->scsi_small;
ss->opcode = MDACMD_SCSI;
if (csio->ccb_h.flags * CAM_DIS_DISCONNECT)
ss->command_control.disable_disconnect = 1;
if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT)
ss->command_control.data_direction = MLY_CCB_WRITE;
ss->data_size = csio->dxfer_len;
ss->addr.phys.lun = csio->ccb_h.target_lun;
ss->addr.phys.target = csio->ccb_h.target_id;
ss->addr.phys.channel = csio->ccb_h.sim_priv.entries[0].field;
if (csio->ccb_h.timeout < (60 * 1000)) {
ss->timeout.value = csio->ccb_h.timeout / 1000;
ss->timeout.scale = MLY_TIMEOUT_SECONDS;
} else if (csio->ccb_h.timeout < (60 * 60 * 1000)) {
ss->timeout.value = csio->ccb_h.timeout / (60 * 1000);
ss->timeout.scale = MLY_TIMEOUT_MINUTES;
} else {
ss->timeout.value = csio->ccb_h.timeout / (60 * 60 * 1000); /* overflow? */
ss->timeout.scale = MLY_TIMEOUT_HOURS;
}
ss->maximum_sense_size = csio->sense_len;
ss->cdb_length = csio->cdb_len;
if (csio->ccb_h.flags & CAM_CDB_POINTER) {
bcopy(csio->cdb_io.cdb_ptr, ss->cdb, csio->cdb_len);
} else {
bcopy(csio->cdb_io.cdb_bytes, ss->cdb, csio->cdb_len);
}
out:
if (error != 0) {
if (mc != NULL) {
mly_release_command(mc);
mc = NULL;
}
if (csio != NULL)
mly_requeue_ccb(sc, (union ccb *)csio);
}
*mcp = mc;
return(error);
}
/********************************************************************************
* Handle completion of a command - pass results back through the CCB
*/
static void
mly_cam_complete(struct mly_command *mc)
{
struct mly_softc *sc = mc->mc_sc;
struct ccb_scsiio *csio = (struct ccb_scsiio *)mc->mc_private;
struct scsi_inquiry_data *inq = (struct scsi_inquiry_data *)csio->data_ptr;
struct mly_btl *btl;
u_int8_t cmd;
int bus, target;
debug_called(2);
csio->scsi_status = mc->mc_status;
switch(mc->mc_status) {
case SCSI_STATUS_OK:
/*
* In order to report logical device type and status, we overwrite
* the result of the INQUIRY command to logical devices.
*/
bus = csio->ccb_h.sim_priv.entries[0].field;
if (bus >= sc->mly_controllerinfo->physical_channels_present) {
if (csio->ccb_h.flags & CAM_CDB_POINTER) {
cmd = *csio->cdb_io.cdb_ptr;
} else {
cmd = csio->cdb_io.cdb_bytes[0];
}
if (cmd == INQUIRY) {
target = csio->ccb_h.target_id;
btl = &sc->mly_btl[bus][target];
padstr(inq->vendor, mly_describe_code(mly_table_device_type, btl->mb_type), 8);
padstr(inq->product, mly_describe_code(mly_table_device_state, btl->mb_state), 16);
padstr(inq->revision, "", 4);
}
}
debug(2, "SCSI_STATUS_OK");
csio->ccb_h.status = CAM_REQ_CMP;
break;
case SCSI_STATUS_CHECK_COND:
debug(2, "SCSI_STATUS_CHECK_COND sense %d resid %d", mc->mc_sense, mc->mc_resid);
csio->ccb_h.status = CAM_SCSI_STATUS_ERROR;
bzero(&csio->sense_data, SSD_FULL_SIZE);
bcopy(mc->mc_packet, &csio->sense_data, mc->mc_sense);
csio->sense_len = mc->mc_sense;
csio->ccb_h.status |= CAM_AUTOSNS_VALID;
csio->resid = mc->mc_resid; /* XXX this is a signed value... */
break;
case SCSI_STATUS_BUSY:
debug(2, "SCSI_STATUS_BUSY");
csio->ccb_h.status = CAM_SCSI_BUSY;
break;
default:
debug(2, "unknown status 0x%x", csio->scsi_status);
csio->ccb_h.status = CAM_REQ_CMP_ERR;
break;
}
xpt_done((union ccb *)csio);
mly_release_command(mc);
}
/********************************************************************************
* Find a peripheral attahed at (bus),(target)
*/
static struct cam_periph *
mly_find_periph(struct mly_softc *sc, int bus, int target)
{
struct cam_periph *periph;
struct cam_path *path;
int status;
status = xpt_create_path(&path, NULL, cam_sim_path(sc->mly_cam_sim[bus]), target, 0);
if (status == CAM_REQ_CMP) {
periph = cam_periph_find(path, NULL);
xpt_free_path(path);
} else {
periph = NULL;
}
return(periph);
}
/********************************************************************************
* Name the device at (bus)(target)
*/
int
mly_name_device(struct mly_softc *sc, int bus, int target)
{
struct cam_periph *periph;
if ((periph = mly_find_periph(sc, bus, target)) != NULL) {
sprintf(sc->mly_btl[bus][target].mb_name, "%s%d", periph->periph_name, periph->unit_number);
return(0);
}
sc->mly_btl[bus][target].mb_name[0] = 0;
return(ENOENT);
}

590
sys/dev/mly/mly_pci.c Normal file
View File

@ -0,0 +1,590 @@
/*-
* 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/malloc.h>
#include <sys/kernel.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/mly/mlyreg.h>
#include <dev/mly/mlyvar.h>
static int mly_pci_probe(device_t dev);
static int mly_pci_attach(device_t dev);
static int mly_pci_detach(device_t dev);
static int mly_pci_shutdown(device_t dev);
static int mly_pci_suspend(device_t dev);
static int mly_pci_resume(device_t dev);
static void mly_pci_intr(void *arg);
static int mly_sg_map(struct mly_softc *sc);
static void mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
static int mly_mmbox_map(struct mly_softc *sc);
static void mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
static void mly_free_command_cluster(struct mly_command_cluster *mcc);
static device_method_t mly_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, mly_pci_probe),
DEVMETHOD(device_attach, mly_pci_attach),
DEVMETHOD(device_detach, mly_pci_detach),
DEVMETHOD(device_shutdown, mly_pci_shutdown),
DEVMETHOD(device_suspend, mly_pci_suspend),
DEVMETHOD(device_resume, mly_pci_resume),
{ 0, 0 }
};
static driver_t mly_pci_driver = {
"mly",
mly_methods,
sizeof(struct mly_softc)
};
static devclass_t mly_devclass;
DRIVER_MODULE(mly, pci, mly_pci_driver, mly_devclass, 0, 0);
struct mly_ident
{
u_int16_t vendor;
u_int16_t device;
u_int16_t subvendor;
u_int16_t subdevice;
int hwif;
char *desc;
} mly_identifiers[] = {
{0x1069, 0xba56, 0x1069, 0x0040, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 2000"},
{0x1069, 0xba56, 0x1069, 0x0030, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 3000"},
{0x1069, 0x0050, 0x1069, 0x0050, MLY_HWIF_I960RX, "Mylex AcceleRAID 352"},
{0x1069, 0x0050, 0x1069, 0x0052, MLY_HWIF_I960RX, "Mylex AcceleRAID 170"},
{0x1069, 0x0050, 0x1069, 0x0054, MLY_HWIF_I960RX, "Mylex AcceleRAID 160"},
{0, 0, 0, 0, 0, 0}
};
/********************************************************************************
********************************************************************************
Bus Interface
********************************************************************************
********************************************************************************/
static int
mly_pci_probe(device_t dev)
{
struct mly_ident *m;
debug_called(1);
for (m = mly_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 == pci_get_subdevice(dev))))) {
device_set_desc(dev, m->desc);
return(-10); /* allow room to be overridden */
}
}
return(ENXIO);
}
static int
mly_pci_attach(device_t dev)
{
struct mly_softc *sc;
int i, error;
u_int32_t command;
debug_called(1);
/*
* Initialise softc.
*/
sc = device_get_softc(dev);
bzero(sc, sizeof(*sc));
sc->mly_dev = dev;
#ifdef MLY_DEBUG
if (device_get_unit(sc->mly_dev) == 0)
mly_softc0 = sc;
#endif
/* assume failure is 'not configured' */
error = ENXIO;
/*
* Verify that the adapter is correctly set up in PCI space.
*/
command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
command |= PCIM_CMD_BUSMASTEREN;
pci_write_config(dev, PCIR_COMMAND, command, 2);
command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
if (!(command & PCIM_CMD_BUSMASTEREN)) {
mly_printf(sc, "can't enable busmaster feature\n");
goto fail;
}
if ((command & PCIM_CMD_MEMEN) == 0) {
mly_printf(sc, "memory window not available\n");
goto fail;
}
/*
* Allocate the PCI register window.
*/
sc->mly_regs_rid = PCIR_MAPS; /* first base address register */
if ((sc->mly_regs_resource = bus_alloc_resource(sc->mly_dev, SYS_RES_MEMORY, &sc->mly_regs_rid,
0, ~0, 1, RF_ACTIVE)) == NULL) {
mly_printf(sc, "can't allocate register window\n");
goto fail;
}
sc->mly_btag = rman_get_bustag(sc->mly_regs_resource);
sc->mly_bhandle = rman_get_bushandle(sc->mly_regs_resource);
/*
* Allocate and connect our interrupt.
*/
sc->mly_irq_rid = 0;
if ((sc->mly_irq = bus_alloc_resource(sc->mly_dev, SYS_RES_IRQ, &sc->mly_irq_rid,
0, ~0, 1, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
mly_printf(sc, "can't allocate interrupt\n");
goto fail;
}
if (bus_setup_intr(sc->mly_dev, sc->mly_irq, INTR_TYPE_CAM, mly_pci_intr, sc, &sc->mly_intr)) {
mly_printf(sc, "can't set up interrupt\n");
goto fail;
}
/* assume failure is 'out of memory' */
error = ENOMEM;
/*
* Allocate the parent bus DMA tag appropriate for our PCI interface.
*
* Note that all 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, MLY_MAXSGENTRIES, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
BUS_DMA_ALLOCNOW, /* flags */
&sc->mly_parent_dmat)) {
mly_printf(sc, "can't allocate parent DMA tag\n");
goto fail;
}
/*
* Create DMA tag for mapping buffers into controller-addressable space.
*/
if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
MAXBSIZE, MLY_MAXSGENTRIES, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
&sc->mly_buffer_dmat)) {
mly_printf(sc, "can't allocate buffer DMA tag\n");
goto fail;
}
/*
* Initialise the DMA tag for command packets.
*/
if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
sizeof(union mly_command_packet) * MLY_CMD_CLUSTERCOUNT, 1, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
&sc->mly_packet_dmat)) {
mly_printf(sc, "can't allocate command packet DMA tag\n");
goto fail;
}
/*
* Detect the hardware interface version
*/
for (i = 0; mly_identifiers[i].vendor != 0; i++) {
if ((mly_identifiers[i].vendor == pci_get_vendor(dev)) &&
(mly_identifiers[i].device == pci_get_device(dev))) {
sc->mly_hwif = mly_identifiers[i].hwif;
switch(sc->mly_hwif) {
case MLY_HWIF_I960RX:
debug(2, "set hardware up for i960RX");
sc->mly_doorbell_true = 0x00;
sc->mly_command_mailbox = MLY_I960RX_COMMAND_MAILBOX;
sc->mly_status_mailbox = MLY_I960RX_STATUS_MAILBOX;
sc->mly_idbr = MLY_I960RX_IDBR;
sc->mly_odbr = MLY_I960RX_ODBR;
sc->mly_error_status = MLY_I960RX_ERROR_STATUS;
sc->mly_interrupt_status = MLY_I960RX_INTERRUPT_STATUS;
sc->mly_interrupt_mask = MLY_I960RX_INTERRUPT_MASK;
break;
case MLY_HWIF_STRONGARM:
debug(2, "set hardware up for StrongARM");
sc->mly_doorbell_true = 0xff; /* doorbell 'true' is 0 */
sc->mly_command_mailbox = MLY_STRONGARM_COMMAND_MAILBOX;
sc->mly_status_mailbox = MLY_STRONGARM_STATUS_MAILBOX;
sc->mly_idbr = MLY_STRONGARM_IDBR;
sc->mly_odbr = MLY_STRONGARM_ODBR;
sc->mly_error_status = MLY_STRONGARM_ERROR_STATUS;
sc->mly_interrupt_status = MLY_STRONGARM_INTERRUPT_STATUS;
sc->mly_interrupt_mask = MLY_STRONGARM_INTERRUPT_MASK;
break;
}
break;
}
}
/*
* Create the scatter/gather mappings.
*/
if ((error = mly_sg_map(sc)))
goto fail;
/*
* Allocate and map the memory mailbox
*/
if ((error = mly_mmbox_map(sc)))
goto fail;
/*
* Do bus-independent initialisation.
*/
if ((error = mly_attach(sc)))
goto fail;
return(0);
fail:
mly_free(sc);
return(error);
}
/********************************************************************************
* Disconnect from the controller completely, in preparation for unload.
*/
static int
mly_pci_detach(device_t dev)
{
struct mly_softc *sc = device_get_softc(dev);
int error;
debug_called(1);
if (sc->mly_state & MLY_STATE_OPEN)
return(EBUSY);
if ((error = mly_pci_shutdown(dev)))
return(error);
mly_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.
*/
static int
mly_pci_shutdown(device_t dev)
{
struct mly_softc *sc = device_get_softc(dev);
debug_called(1);
mly_detach(sc);
return(0);
}
/********************************************************************************
* Bring the controller to a quiescent state, ready for system suspend.
*
* We can't assume that the controller is not active at this point, so we need
* to mask interrupts.
*/
static int
mly_pci_suspend(device_t dev)
{
struct mly_softc *sc = device_get_softc(dev);
int s;
debug_called(1);
s = splcam();
mly_detach(sc);
splx(s);
return(0);
}
/********************************************************************************
* Bring the controller back to a state ready for operation.
*/
static int
mly_pci_resume(device_t dev)
{
struct mly_softc *sc = device_get_softc(dev);
debug_called(1);
sc->mly_state &= ~MLY_STATE_SUSPEND;
MLY_UNMASK_INTERRUPTS(sc);
return(0);
}
/*******************************************************************************
* Take an interrupt, or be poked by other code to look for interrupt-worthy
* status.
*/
static void
mly_pci_intr(void *arg)
{
struct mly_softc *sc = (struct mly_softc *)arg;
debug_called(3);
/* collect finished commands, queue anything waiting */
mly_done(sc);
};
/********************************************************************************
********************************************************************************
Bus-dependant Resource Management
********************************************************************************
********************************************************************************/
/********************************************************************************
* Allocate memory for the scatter/gather tables
*/
static int
mly_sg_map(struct mly_softc *sc)
{
size_t segsize;
debug_called(1);
/*
* Create a single tag describing a region large enough to hold all of
* the s/g lists we will need.
*/
segsize = sizeof(struct mly_sg_entry) * MLY_MAXCOMMANDS * MLY_MAXSGENTRIES;
if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
segsize, 1, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
&sc->mly_sg_dmat)) {
mly_printf(sc, "can't allocate scatter/gather DMA tag\n");
return(ENOMEM);
}
/*
* Allocate enough s/g maps for all commands and permanently map them into
* controller-visible space.
*
* XXX this assumes we can get enough space for all the s/g maps in one
* contiguous slab.
*/
if (bus_dmamem_alloc(sc->mly_sg_dmat, (void **)&sc->mly_sg_table, BUS_DMA_NOWAIT, &sc->mly_sg_dmamap)) {
mly_printf(sc, "can't allocate s/g table\n");
return(ENOMEM);
}
bus_dmamap_load(sc->mly_sg_dmat, sc->mly_sg_dmamap, sc->mly_sg_table, segsize, mly_sg_map_helper, sc, 0);
return(0);
}
/********************************************************************************
* Save the physical address of the base of the s/g table.
*/
static void
mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
{
struct mly_softc *sc = (struct mly_softc *)arg;
debug_called(2);
/* save base of s/g table's address in bus space */
sc->mly_sg_busaddr = segs->ds_addr;
}
/********************************************************************************
* Allocate memory for the memory-mailbox interface
*/
static int
mly_mmbox_map(struct mly_softc *sc)
{
/*
* Create a DMA tag for a single contiguous region large enough for the
* memory mailbox structure.
*/
if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
sizeof(struct mly_mmbox), 1, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
&sc->mly_mmbox_dmat)) {
mly_printf(sc, "can't allocate memory mailbox DMA tag\n");
return(ENOMEM);
}
/*
* Allocate the buffer
*/
if (bus_dmamem_alloc(sc->mly_mmbox_dmat, (void **)&sc->mly_mmbox, BUS_DMA_NOWAIT, &sc->mly_mmbox_dmamap)) {
mly_printf(sc, "can't allocate memory mailbox\n");
return(ENOMEM);
}
bus_dmamap_load(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap, sc->mly_mmbox, sizeof(struct mly_mmbox),
mly_mmbox_map_helper, sc, 0);
bzero(sc->mly_mmbox, sizeof(*sc->mly_mmbox));
return(0);
}
/********************************************************************************
* Save the physical address of the memory mailbox
*/
static void
mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
{
struct mly_softc *sc = (struct mly_softc *)arg;
debug_called(2);
sc->mly_mmbox_busaddr = segs->ds_addr;
}
/********************************************************************************
* Free all of the resources associated with (sc)
*
* Should not be called if the controller is active.
*/
void
mly_free(struct mly_softc *sc)
{
struct mly_command_cluster *mcc;
debug_called(1);
/* detach from CAM */
mly_cam_detach(sc);
/* throw away any command buffers */
while ((mcc = mly_dequeue_cluster(sc)) != NULL)
mly_free_command_cluster(mcc);
/* throw away the controllerinfo structure */
if (sc->mly_controllerinfo != NULL)
free(sc->mly_controllerinfo, M_DEVBUF);
/* throw away the controllerparam structure */
if (sc->mly_controllerparam != NULL)
free(sc->mly_controllerparam, M_DEVBUF);
/* destroy data-transfer DMA tag */
if (sc->mly_buffer_dmat)
bus_dma_tag_destroy(sc->mly_buffer_dmat);
/* free and destroy DMA memory and tag for s/g lists */
if (sc->mly_sg_table) {
bus_dmamap_unload(sc->mly_sg_dmat, sc->mly_sg_dmamap);
bus_dmamem_free(sc->mly_sg_dmat, sc->mly_sg_table, sc->mly_sg_dmamap);
}
if (sc->mly_sg_dmat)
bus_dma_tag_destroy(sc->mly_sg_dmat);
/* free and destroy DMA memory and tag for memory mailbox */
if (sc->mly_mmbox) {
bus_dmamap_unload(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap);
bus_dmamem_free(sc->mly_mmbox_dmat, sc->mly_mmbox, sc->mly_mmbox_dmamap);
}
if (sc->mly_mmbox_dmat)
bus_dma_tag_destroy(sc->mly_mmbox_dmat);
/* disconnect the interrupt handler */
if (sc->mly_intr)
bus_teardown_intr(sc->mly_dev, sc->mly_irq, sc->mly_intr);
if (sc->mly_irq != NULL)
bus_release_resource(sc->mly_dev, SYS_RES_IRQ, sc->mly_irq_rid, sc->mly_irq);
/* destroy the parent DMA tag */
if (sc->mly_parent_dmat)
bus_dma_tag_destroy(sc->mly_parent_dmat);
/* release the register window mapping */
if (sc->mly_regs_resource != NULL)
bus_release_resource(sc->mly_dev, SYS_RES_MEMORY, sc->mly_regs_rid, sc->mly_regs_resource);
}
/********************************************************************************
* Free a command cluster.
*/
static void
mly_free_command_cluster(struct mly_command_cluster *mcc)
{
struct mly_softc *sc = mcc->mcc_command[0].mc_sc;
int i;
debug_called(1);
for (i = 0; i < MLY_CMD_CLUSTERCOUNT; i++)
bus_dmamap_destroy(sc->mly_buffer_dmat, mcc->mcc_command[i].mc_datamap);
bus_dmamap_unload(sc->mly_packet_dmat, mcc->mcc_packetmap);
bus_dmamem_free(sc->mly_packet_dmat, mcc->mcc_packet, mcc->mcc_packetmap);
free(mcc, M_DEVBUF);
}

335
sys/dev/mly/mly_tables.h Normal file
View File

@ -0,0 +1,335 @@
/*-
* 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$
*/
/*
* Lookup table for code-to-text translations.
*/
struct mly_code_lookup {
char *string;
u_int32_t code;
};
extern char *mly_describe_code(struct mly_code_lookup *table, u_int32_t code);
#ifndef MLY_DEFINE_TABLES
extern struct mly_code_lookup mly_table_bustype[];
extern struct mly_code_lookup mly_table_controllertype[];
extern struct mly_code_lookup mly_table_oemname[];
extern struct mly_code_lookup mly_table_memorytype[];
extern struct mly_code_lookup mly_table_cputype[];
extern struct mly_code_lookup mly_table_event[];
extern struct mly_code_lookup mly_table_device_state[];
extern struct mly_code_lookup mly_table_device_type[];
extern struct mly_code_lookup mly_table_stripe_size[];
extern struct mly_code_lookup mly_table_cacheline_size[];
#else /* MLY_DEFINE_TABLES */
/********************************************************************************
* Look up a text description of a numeric code and return a pointer to same.
*/
char *
mly_describe_code(struct mly_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);
}
struct mly_code_lookup mly_table_bustype[] = {
{"SCSI", 0x00},
{"FC-AL", 0x01},
{"PCI", 0x03},
{NULL, 0},
{"unknown bus", 0}
};
struct mly_code_lookup mly_table_controllertype[] = {
#if 0 /* not supported by this driver */
{"DAC960E", 0x01}, /* EISA */
{"DAC960M", 0x08}, /* MCA */
{"DAC960PD", 0x10}, /* PCI Dual */
{"DAC960PL", 0x11}, /* PCU low-cost */
{"DAC960PDU", 0x12}, /* PD Ultra */
{"DAC960PE", 0x13}, /* Peregrine low-cost */
{"DAC960PG", 0x14}, /* Peregrine high-performance */
{"DAC960PJ", 0x15}, /* Road Runner */
{"DAC960PTL0", 0x16}, /* Jaguar */
{"DAC960PR", 0x17}, /* Road Runner (again?) */
{"DAC960PRL", 0x18}, /* Tomcat */
{"DAC960PT", 0x19}, /* Road Runner (yet again?) */
{"DAC1164P", 0x1a}, /* Little Apple */
{"DAC960PTL1", 0x1b}, /* Jaguar+ */
#endif
{"EXR2000P", 0x1c}, /* Big Apple */
{"EXR3000P", 0x1d}, /* Fibre Apple */
{"AcceleRAID 352", 0x1e}, /* Leopard */
{"AcceleRAID 170", 0x1f}, /* Lynx */
{"AcceleRAID 160", 0x20}, /* Bobcat */
{NULL, 0},
{"unknown adapter", 0}
};
struct mly_code_lookup mly_table_oemname[] = {
{"Mylex", MLY_OEM_MYLEX},
{"IBM", MLY_OEM_IBM},
{"Hewlett-Packard", MLY_OEM_HP},
{"DEC/Compaq", MLY_OEM_DEC},
{"Siemens", MLY_OEM_SIEMENS},
{"Intel", MLY_OEM_INTEL},
{NULL, 0},
{"unknown OEM", 0}
};
struct mly_code_lookup mly_table_memorytype[] = {
{"DRAM", 0x01},
{"EDRAM", 0x02},
{"EDO RAM", 0x03},
{"SDRAM", 0x04},
{NULL, 0},
{"unknown memory", 0}
};
struct mly_code_lookup mly_table_cputype[] = {
{"i960CA", 0x01},
{"i960RD", 0x02},
{"i960RN", 0x03},
{"i960RP", 0x04},
{"NorthBay(?)", 0x05},
{"StrongArm", 0x06},
{"i960RM", 0x07},
{NULL, 0},
{"unknown CPU", 0}
};
/*
* This table is directly derived from the corresponding table in the
* Linux driver, and uses a derivative encoding for simplicity's sake.
*
* The first character of the string determines the format of the message.
*
* p "physical device <channel>:<target> <text>" (physical device status)
* s "physical device <channel>:<target> <text>" (scsi message or error)
* " sense key <key> asc <asc> ascq <ascq>"
* " info <info> csi <csi>"
* l "logical drive <unit>: <text>" (logical device status)
* m "logical drive <unit>: <text>" (logical device message)
*
* Messages which are typically suppressed have the first character capitalised.
* These messages will only be printed if bootverbose is set.
*
* The second character in the string indicates an action to be taken as a
* result of the event.
*
* r rescan the device for possible state change
*
*/
struct mly_code_lookup mly_table_event[] = {
/* physical device events (0x0000 - 0x007f) */
{"pr online", 0x0001},
{"pr standby", 0x0002},
{"p automatic rebuild started", 0x0005},
{"p manual rebuild started", 0x0006},
{"pr rebuild completed", 0x0007},
{"pr rebuild cancelled", 0x0008},
{"pr rebuild failed for unknown reasons", 0x0009},
{"pr rebuild failed due to new physical device", 0x000a},
{"pr rebuild failed due to logical drive failure", 0x000b},
{"sr offline", 0x000c},
{"pr found", 0x000d},
{"pr gone", 0x000e},
{"p unconfigured", 0x000f},
{"p expand capacity started", 0x0010},
{"pr expand capacity completed", 0x0011},
{"pr expand capacity failed", 0x0012},
{"p parity error", 0x0016},
{"p soft error", 0x0017},
{"p miscellaneous error", 0x0018},
{"p reset", 0x0019},
{"p active spare found", 0x001a},
{"p warm spare found", 0x001b},
{"s sense data received", 0x001c},
{"p initialization started", 0x001d},
{"pr initialization completed", 0x001e},
{"pr initialization failed", 0x001f},
{"pr initialization cancelled", 0x0020},
{"P write recovery failed", 0x0021},
{"p scsi bus reset failed", 0x0022},
{"p double check condition", 0x0023},
{"p device cannot be accessed", 0x0024},
{"p gross error on scsi processor", 0x0025},
{"p bad tag from device", 0x0026},
{"p command timeout", 0x0027},
{"pr system reset", 0x0028},
{"p busy status or parity error", 0x0029},
{"pr host set device to failed state", 0x002a},
{"pr selection timeout", 0x002b},
{"p scsi bus phase error", 0x002c},
{"pr device returned unknown status", 0x002d},
{"pr device not ready", 0x002e},
{"p device not found at startup", 0x002f},
{"p COD write operation failed", 0x0030},
{"p BDT write operation failed", 0x0031},
{"p missing at startup", 0x0039},
{"p start rebuild failed due to physical drive too small", 0x003a},
/* logical device events (0x0080 - 0x00ff) */
{"m consistency check started", 0x0080},
{"mr consistency check completed", 0x0081},
{"mr consistency check cancelled", 0x0082},
{"mr consistency check completed with errors", 0x0083},
{"mr consistency check failed due to logical drive failure", 0x0084},
{"mr consistency check failed due to physical device failure", 0x0085},
{"lr offline", 0x0086},
{"lr critical", 0x0087},
{"lr online", 0x0088},
{"m automatic rebuild started", 0x0089},
{"m manual rebuild started", 0x008a},
{"mr rebuild completed", 0x008b},
{"mr rebuild cancelled", 0x008c},
{"mr rebuild failed for unknown reasons", 0x008d},
{"mr rebuild failed due to new physical device", 0x008e},
{"mr rebuild failed due to logical drive failure", 0x008f},
{"l initialization started", 0x0090},
{"lr initialization completed", 0x0091},
{"lr initialization cancelled", 0x0092},
{"lr initialization failed", 0x0093},
{"lr found", 0x0094},
{"lr gone", 0x0095},
{"l expand capacity started", 0x0096},
{"lr expand capacity completed", 0x0097},
{"lr expand capacity failed", 0x0098},
{"l bad block found", 0x0099},
{"lr size changed", 0x009a},
{"lr type changed", 0x009b},
{"l bad data block found", 0x009c},
{"l read of data block in bdt", 0x009e},
{"l write back data for disk block lost", 0x009f},
/* enclosure management events (0x0100 - 0x017f) */
{"e enclosure %d fan %d failed", 0x0140},
{"e enclosure %d fan %d ok", 0x0141},
{"e enclosure %d fan %d not present", 0x0142},
{"e enclosure %d power supply %d failed", 0x0143},
{"e enclosure %d power supply %d ok", 0x0144},
{"e enclosure %d power supply %d not present", 0x0145},
{"e enclosure %d temperature sensor %d failed", 0x0146},
{"e enclosure %d temperature sensor %d critical", 0x0147},
{"e enclosure %d temperature sensor %d ok", 0x0148},
{"e enclosure %d temperature sensor %d not present", 0x0149},
{"e enclosure %d unit %d access critical", 0x014a},
{"e enclosure %d unit %d access ok", 0x014b},
{"e enclosure %d unit %d access offline", 0x014c},
/* controller events (0x0180 - 0x01ff) */
{"c cache write back error", 0x0181},
{"c battery backup unit found", 0x0188},
{"c battery backup unit charge level low", 0x0189},
{"c battery backup unit charge level ok", 0x018a},
{"c installation aborted", 0x0193},
{"c mirror race recovery in progress", 0x0195},
{"c mirror race on critical drive", 0x0196},
{"c memory soft ecc error", 0x019e},
{"c memory hard ecc error", 0x019f},
{"c battery backup unit failed", 0x01a2},
{NULL, 0},
{"? unknown event code", 0}
};
/*
* Values here must be 16 characters or less, as they are packed into
* the 'product' field in the SCSI inquiry data.
*/
struct mly_code_lookup mly_table_device_state[] = {
{"offline", MLY_DEVICE_STATE_OFFLINE},
{"unconfigured", MLY_DEVICE_STATE_UNCONFIGURED},
{"online", MLY_DEVICE_STATE_ONLINE},
{"critical", MLY_DEVICE_STATE_CRITICAL},
{"writeonly", MLY_DEVICE_STATE_WRITEONLY},
{"standby", MLY_DEVICE_STATE_STANDBY},
{"missing", MLY_DEVICE_STATE_MISSING},
{NULL, 0},
{"unknown state", 0}
};
/*
* Values here must be 8 characters or less, as they are packed into
* the 'vendor' field in the SCSI inquiry data.
*/
struct mly_code_lookup mly_table_device_type[] = {
{"RAID 0", MLY_DEVICE_TYPE_RAID0},
{"RAID 1", MLY_DEVICE_TYPE_RAID1},
{"RAID 3", MLY_DEVICE_TYPE_RAID3}, /* right asymmetric parity */
{"RAID 5", MLY_DEVICE_TYPE_RAID5}, /* right asymmetric parity */
{"RAID 6", MLY_DEVICE_TYPE_RAID6}, /* Mylex RAID 6 */
{"RAID 7", MLY_DEVICE_TYPE_RAID7}, /* JBOD */
{"SPAN", MLY_DEVICE_TYPE_NEWSPAN}, /* New Mylex SPAN */
{"RAID 3", MLY_DEVICE_TYPE_RAID3F}, /* fixed parity */
{"RAID 3", MLY_DEVICE_TYPE_RAID3L}, /* left symmetric parity */
{"SPAN", MLY_DEVICE_TYPE_SPAN}, /* current spanning implementation */
{"RAID 5", MLY_DEVICE_TYPE_RAID5L}, /* left symmetric parity */
{"RAID E", MLY_DEVICE_TYPE_RAIDE}, /* concatenation */
{"PHYSICAL", MLY_DEVICE_TYPE_PHYSICAL}, /* physical device */
{NULL, 0},
{"UNKNOWN", 0}
};
struct mly_code_lookup mly_table_stripe_size[] = {
{"NONE", MLY_STRIPE_ZERO},
{"512B", MLY_STRIPE_512b},
{"1k", MLY_STRIPE_1k},
{"2k", MLY_STRIPE_2k},
{"4k", MLY_STRIPE_4k},
{"8k", MLY_STRIPE_8k},
{"16k", MLY_STRIPE_16k},
{"32k", MLY_STRIPE_32k},
{"64k", MLY_STRIPE_64k},
{"128k", MLY_STRIPE_128k},
{"256k", MLY_STRIPE_256k},
{"512k", MLY_STRIPE_512k},
{"1M", MLY_STRIPE_1m},
{NULL, 0},
{"unknown", 0}
};
struct mly_code_lookup mly_table_cacheline_size[] = {
{"NONE", MLY_CACHELINE_ZERO},
{"512B", MLY_CACHELINE_512b},
{"1k", MLY_CACHELINE_1k},
{"2k", MLY_CACHELINE_2k},
{"4k", MLY_CACHELINE_4k},
{"8k", MLY_CACHELINE_8k},
{"16k", MLY_CACHELINE_16k},
{"32k", MLY_CACHELINE_32k},
{"64k", MLY_CACHELINE_64k},
{NULL, 0},
{"unknown", 0}
};
#endif /* MLY_DEFINE_TABLES */

1270
sys/dev/mly/mlyreg.h Normal file
View File

File diff suppressed because it is too large Load Diff

423
sys/dev/mly/mlyvar.h Normal file
View File

@ -0,0 +1,423 @@
/*-
* 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 command identifier. A lookup
* table this size (256k) would be too expensive, so we cap ourselves at a
* reasonable limit.
*/
#define MLY_MAXCOMMANDS 256 /* max outstanding commands per controller, limit 65535 */
/*
* The firmware interface allows for a 16-bit s/g list length. We limit
* ourselves to a reasonable maximum and ensure alignment.
*/
#define MLY_MAXSGENTRIES 64 /* max S/G entries, limit 65535 */
/********************************************************************************
********************************************************************************
Driver Variable Definitions
********************************************************************************
********************************************************************************/
#if __FreeBSD_version >= 500005
# include <sys/taskqueue.h>
#endif
/*
* 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 MLY_DEBUG
# define debug(level, fmt, args...) do { if (level <= MLY_DEBUG) printf("%s: " fmt "\n", __FUNCTION__ , ##args); } while(0)
# define debug_called(level) do { if (level <= MLY_DEBUG) printf(__FUNCTION__ ": called\n"); } while(0)
# define debug_struct(s) printf(" SIZE %s: %d\n", #s, sizeof(struct s))
# define debug_union(s) printf(" SIZE %s: %d\n", #s, sizeof(union s))
# define debug_field(s, f) printf(" OFFSET %s.%s: %d\n", #s, #f, ((int)&(((struct s *)0)->f)))
extern void mly_printstate0(void);
extern struct mly_softc *mly_softc0;
#else
# define debug(level, fmt, args...)
# define debug_called(level)
# define debug_struct(s)
#endif
#define mly_printf(sc, fmt, args...) device_printf(sc->mly_dev, fmt , ##args)
/*
* Per-device structure, used to save persistent state on devices.
*
* Note that this isn't really Bus/Target/Lun since we don't support
* lun != 0 at this time.
*/
struct mly_btl {
int mb_flags;
#define MLY_BTL_PHYSICAL (1<<0) /* physical device */
#define MLY_BTL_LOGICAL (1<<1) /* logical device */
#define MLY_BTL_PROTECTED (1<<2) /* device is protected - I/O not allowed */
#define MLY_BTL_RESCAN (1<<3) /* device needs to be rescanned */
char mb_name[16]; /* peripheral attached to this device */
int mb_state; /* see 8.1 */
int mb_type; /* see 8.2 */
};
/*
* Per-command control structure.
*/
struct mly_command {
TAILQ_ENTRY(mly_command) mc_link; /* list linkage */
struct mly_softc *mc_sc; /* controller that owns us */
u_int16_t mc_slot; /* command slot we occupy */
int mc_flags;
#define MLY_CMD_STATEMASK ((1<<8)-1)
#define MLY_CMD_STATE(mc) ((mc)->mc_flags & MLY_CMD_STATEMASK)
#define MLY_CMD_SETSTATE(mc, s) ((mc)->mc_flags = ((mc)->mc_flags &= ~MLY_CMD_STATEMASK) | (s))
#define MLY_CMD_FREE 0 /* command is on the free list */
#define MLY_CMD_SETUP 1 /* command is being built */
#define MLY_CMD_BUSY 2 /* command is being run, or ready to run, or not completed */
#define MLY_CMD_COMPLETE 3 /* command has been completed */
#define MLY_CMD_SLOTTED (1<<8) /* command has a slot number */
#define MLY_CMD_MAPPED (1<<9) /* command has had its data mapped */
#define MLY_CMD_PRIORITY (1<<10) /* allow use of "priority" slots */
#define MLY_CMD_DATAIN (1<<11) /* data moves controller->system */
#define MLY_CMD_DATAOUT (1<<12) /* data moves system->controller */
u_int16_t mc_status; /* command completion status */
u_int8_t mc_sense; /* sense data length */
int32_t mc_resid; /* I/O residual count */
union mly_command_packet *mc_packet; /* our controller command */
u_int64_t mc_packetphys; /* physical address of the mapped packet */
void *mc_data; /* data buffer */
size_t mc_length; /* data length */
bus_dmamap_t mc_datamap; /* DMA map for data */
void (* mc_complete)(struct mly_command *mc); /* completion handler */
void *mc_private; /* caller-private data */
};
/*
* Command slot regulation.
*
* We can't use slot 0 due to the memory mailbox implementation.
*/
#define MLY_SLOT_START 1
#define MLY_SLOT_MAX (MLY_SLOT_START + MLY_MAXCOMMANDS)
/*
* 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 caused by allocating lots of these small structures.
*
* Note that it is possible to require more than MLY_MAXCOMMANDS
* command structures.
*
* Since we may need to allocate extra clusters at any time, and since this
* process needs to allocate a physically contiguous slab of controller
* addressible memory in which to place the command packets, do not allow more
* command packets in a cluster than will fit in a page.
*/
#define MLY_CMD_CLUSTERCOUNT (PAGE_SIZE / sizeof(union mly_command_packet))
struct mly_command_cluster {
TAILQ_ENTRY(mly_command_cluster) mcc_link;
union mly_command_packet *mcc_packet;
bus_dmamap_t mcc_packetmap;
u_int64_t mcc_packetphys;
struct mly_command mcc_command[MLY_CMD_CLUSTERCOUNT];
};
/*
* Per-controller structure.
*/
struct mly_softc {
/* bus connections */
device_t mly_dev;
struct resource *mly_regs_resource; /* register interface window */
int mly_regs_rid; /* resource ID */
bus_space_handle_t mly_bhandle; /* bus space handle */
bus_space_tag_t mly_btag; /* bus space tag */
bus_dma_tag_t mly_parent_dmat; /* parent DMA tag */
bus_dma_tag_t mly_buffer_dmat; /* data buffer/command DMA tag */
struct resource *mly_irq; /* interrupt */
int mly_irq_rid;
void *mly_intr; /* interrupt handle */
/* scatter/gather lists and their controller-visible mappings */
struct mly_sg_entry *mly_sg_table; /* s/g lists */
u_int32_t mly_sg_busaddr; /* s/g table base address in bus space */
bus_dma_tag_t mly_sg_dmat; /* s/g buffer DMA tag */
bus_dmamap_t mly_sg_dmamap; /* map for s/g buffers */
/* controller hardware interface */
int mly_hwif;
#define MLY_HWIF_I960RX 0
#define MLY_HWIF_STRONGARM 1
u_int8_t mly_doorbell_true; /* xor map to make hardware doorbell 'true' bits into 1s */
u_int8_t mly_command_mailbox; /* register offsets */
u_int8_t mly_status_mailbox;
u_int8_t mly_idbr;
u_int8_t mly_odbr;
u_int8_t mly_error_status;
u_int8_t mly_interrupt_status;
u_int8_t mly_interrupt_mask;
struct mly_mmbox *mly_mmbox; /* kernel-space address of memory mailbox */
u_int64_t mly_mmbox_busaddr; /* bus-space address of memory mailbox */
bus_dma_tag_t mly_mmbox_dmat; /* memory mailbox DMA tag */
bus_dmamap_t mly_mmbox_dmamap; /* memory mailbox DMA map */
u_int32_t mly_mmbox_command_index; /* next slot to use */
u_int32_t mly_mmbox_status_index; /* slot we next expect status in */
/* controller features, limits and status */
int mly_state;
#define MLY_STATE_SUSPEND (1<<0)
#define MLY_STATE_OPEN (1<<1)
#define MLY_STATE_INTERRUPTS_ON (1<<2)
#define MLY_STATE_MMBOX_ACTIVE (1<<3)
int mly_max_commands; /* max parallel commands we allow */
struct mly_ioctl_getcontrollerinfo *mly_controllerinfo;
struct mly_param_controller *mly_controllerparam;
struct mly_btl mly_btl[MLY_MAX_CHANNELS][MLY_MAX_TARGETS];
/* command management */
struct mly_command *mly_busycmds[MLY_SLOT_MAX]; /* busy commands */
int mly_busy_count;
int mly_last_slot;
TAILQ_HEAD(,mly_command) mly_freecmds; /* commands available for reuse */
TAILQ_HEAD(,mly_command) mly_ready; /* commands ready to be submitted */
TAILQ_HEAD(,mly_command) mly_completed; /* commands which have been returned by the controller */
TAILQ_HEAD(,mly_command_cluster) mly_clusters; /* command memory blocks */
bus_dma_tag_t mly_packet_dmat; /* command packet DMA tag */
/* health monitoring */
u_int32_t mly_event_change; /* event status change indicator */
u_int32_t mly_event_counter; /* next event for which we anticpiate status */
u_int32_t mly_event_waiting; /* next event the controller will post status for */
struct callout_handle mly_periodic; /* periodic event handling */
/* CAM connection */
TAILQ_HEAD(,ccb_hdr) mly_cam_ccbq; /* outstanding I/O from CAM */
struct cam_sim *mly_cam_sim[MLY_MAX_CHANNELS];
int mly_cam_lowbus;
#if __FreeBSD_version >= 500005
/* command-completion task */
struct task mly_task_complete; /* deferred-completion task */
#endif
};
/*
* Register access helpers.
*/
#define MLY_SET_REG(sc, reg, val) bus_space_write_1(sc->mly_btag, sc->mly_bhandle, reg, val)
#define MLY_GET_REG(sc, reg) bus_space_read_1 (sc->mly_btag, sc->mly_bhandle, reg)
#define MLY_GET_REG2(sc, reg) bus_space_read_2 (sc->mly_btag, sc->mly_bhandle, reg)
#define MLY_GET_REG4(sc, reg) bus_space_read_4 (sc->mly_btag, sc->mly_bhandle, reg)
#define MLY_SET_MBOX(sc, mbox, ptr) \
do { \
bus_space_write_4(sc->mly_btag, sc->mly_bhandle, mbox, *((u_int32_t *)ptr)); \
bus_space_write_4(sc->mly_btag, sc->mly_bhandle, mbox + 4, *((u_int32_t *)ptr + 1)); \
bus_space_write_4(sc->mly_btag, sc->mly_bhandle, mbox + 8, *((u_int32_t *)ptr + 2)); \
bus_space_write_4(sc->mly_btag, sc->mly_bhandle, mbox + 12, *((u_int32_t *)ptr + 3)); \
} while(0);
#define MLY_GET_MBOX(sc, mbox, ptr) \
do { \
*((u_int32_t *)ptr) = bus_space_read_4(sc->mly_btag, sc->mly_bhandle, mbox); \
*((u_int32_t *)ptr + 1) = bus_space_read_4(sc->mly_btag, sc->mly_bhandle, mbox + 4); \
*((u_int32_t *)ptr + 2) = bus_space_read_4(sc->mly_btag, sc->mly_bhandle, mbox + 8); \
*((u_int32_t *)ptr + 3) = bus_space_read_4(sc->mly_btag, sc->mly_bhandle, mbox + 12); \
} while(0);
#define MLY_IDBR_TRUE(sc, mask) \
((((MLY_GET_REG((sc), (sc)->mly_idbr)) ^ (sc)->mly_doorbell_true) & (mask)) == (mask))
#define MLY_ODBR_TRUE(sc, mask) \
((MLY_GET_REG((sc), (sc)->mly_odbr) & (mask)) == (mask))
#define MLY_ERROR_VALID(sc) \
((((MLY_GET_REG((sc), (sc)->mly_error_status)) ^ (sc)->mly_doorbell_true) & (MLY_MSG_EMPTY)) == 0)
#define MLY_MASK_INTERRUPTS(sc) \
do { \
MLY_SET_REG((sc), (sc)->mly_interrupt_mask, MLY_INTERRUPT_MASK_DISABLE); \
sc->mly_state &= ~MLY_STATE_INTERRUPTS_ON; \
} while(0);
#define MLY_UNMASK_INTERRUPTS(sc) \
do { \
MLY_SET_REG((sc), (sc)->mly_interrupt_mask, MLY_INTERRUPT_MASK_ENABLE); \
sc->mly_state |= MLY_STATE_INTERRUPTS_ON; \
} while(0);
/*
* Logical device number -> bus/target translation
*/
#define MLY_LOGDEV_BUS(sc, x) (((x) / MLY_MAX_TARGETS) + (sc)->mly_controllerinfo->physical_channels_present)
#define MLY_LOGDEV_TARGET(x) ((x) % MLY_MAX_TARGETS)
/*
* Public functions/variables
*/
/* mly.c */
extern int mly_attach(struct mly_softc *sc);
extern void mly_detach(struct mly_softc *sc);
extern void mly_free(struct mly_softc *sc);
extern void mly_startio(struct mly_softc *sc);
extern void mly_done(struct mly_softc *sc);
extern int mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp);
extern void mly_release_command(struct mly_command *mc);
/* mly_cam.c */
extern int mly_cam_attach(struct mly_softc *sc);
extern void mly_cam_detach(struct mly_softc *sc);
extern int mly_cam_command(struct mly_softc *sc, struct mly_command **mcp);
extern int mly_name_device(struct mly_softc *sc, int bus, int target);
/********************************************************************************
* Queue primitives
*
* These are broken out individually to make statistics gathering easier.
*/
static __inline void
mly_enqueue_ready(struct mly_command *mc)
{
int s;
s = splcam();
TAILQ_INSERT_TAIL(&mc->mc_sc->mly_ready, mc, mc_link);
MLY_CMD_SETSTATE(mc, MLY_CMD_BUSY);
splx(s);
}
static __inline void
mly_requeue_ready(struct mly_command *mc)
{
int s;
s = splcam();
TAILQ_INSERT_HEAD(&mc->mc_sc->mly_ready, mc, mc_link);
splx(s);
}
static __inline struct mly_command *
mly_dequeue_ready(struct mly_softc *sc)
{
struct mly_command *mc;
int s;
s = splcam();
if ((mc = TAILQ_FIRST(&sc->mly_ready)) != NULL)
TAILQ_REMOVE(&sc->mly_ready, mc, mc_link);
splx(s);
return(mc);
}
static __inline void
mly_enqueue_completed(struct mly_command *mc)
{
int s;
s = splcam();
TAILQ_INSERT_TAIL(&mc->mc_sc->mly_completed, mc, mc_link);
/* don't set MLY_CMD_COMPLETE here to avoid wakeup race */
splx(s);
}
static __inline struct mly_command *
mly_dequeue_completed(struct mly_softc *sc)
{
struct mly_command *mc;
int s;
s = splcam();
if ((mc = TAILQ_FIRST(&sc->mly_completed)) != NULL)
TAILQ_REMOVE(&sc->mly_completed, mc, mc_link);
splx(s);
return(mc);
}
static __inline void
mly_enqueue_free(struct mly_command *mc)
{
int s;
s = splcam();
TAILQ_INSERT_HEAD(&mc->mc_sc->mly_freecmds, mc, mc_link);
MLY_CMD_SETSTATE(mc, MLY_CMD_FREE);
splx(s);
}
static __inline struct mly_command *
mly_dequeue_free(struct mly_softc *sc)
{
struct mly_command *mc;
int s;
s = splcam();
if ((mc = TAILQ_FIRST(&sc->mly_freecmds)) != NULL)
TAILQ_REMOVE(&sc->mly_freecmds, mc, mc_link);
splx(s);
return(mc);
}
static __inline void
mly_enqueue_cluster(struct mly_softc *sc, struct mly_command_cluster *mcc)
{
int s;
s = splcam();
TAILQ_INSERT_HEAD(&sc->mly_clusters, mcc, mcc_link);
splx(s);
}
static __inline struct mly_command_cluster *
mly_dequeue_cluster(struct mly_softc *sc)
{
struct mly_command_cluster *mcc;
int s;
s = splcam();
if ((mcc = TAILQ_FIRST(&sc->mly_clusters)) != NULL)
TAILQ_REMOVE(&sc->mly_clusters, mcc, mcc_link);
splx(s);
return(mcc);
}

2
sys/modules/Makefile
View File

@ -9,7 +9,7 @@ _randomdev= randomdev
SUBDIR= 3dfx accf_data accf_http agp aha amr an aue \
cam ccd cd9660 coda cue dc fdesc fxp if_disc if_ef \
if_ppp if_sl if_tap if_tun ipfilter ipfw ispfw joy kernfs kue \
md mfs mii mlx msdos ncp netgraph nfs ntfs nullfs \
md mfs mii mlx mly msdos ncp netgraph nfs ntfs nullfs \
nwfs oldcard pcic portal procfs ${_randomdev} \
rl rp sf sis sk sn sound ste syscons ti tl twe tx \
udbp ugen uhid ukbd ulpt umapfs umass umodem ums union urio usb \

11
sys/modules/mly/Makefile Normal file
View File

@ -0,0 +1,11 @@
# $FreeBSD$
.PATH: ${.CURDIR}/../../dev/mly
KMOD = mly
SRCS = mly.c mly_pci.c mly_cam.c
SRCS += opt_scsi.h opt_cam.h
SRCS += device_if.h bus_if.h pci_if.h
#CFLAGS+= -DMLY_DEBUG=1
.include <bsd.kmod.mk>