This is the initial import of a new driver for the current family of
PCI:SCSI RAID controllers from Mylex.
This commit is contained in:
parent
c1e6727a77
commit
e07acca5f0
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=64987
@ -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
1711
sys/dev/mly/mly.c
Normal file
File diff suppressed because it is too large
Load Diff
513
sys/dev/mly/mly_cam.c
Normal file
513
sys/dev/mly/mly_cam.c
Normal 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
590
sys/dev/mly/mly_pci.c
Normal 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
335
sys/dev/mly/mly_tables.h
Normal 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
1270
sys/dev/mly/mlyreg.h
Normal file
File diff suppressed because it is too large
Load Diff
423
sys/dev/mly/mlyvar.h
Normal file
423
sys/dev/mly/mlyvar.h
Normal 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);
|
||||
}
|
||||
|
||||
|
@ -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
11
sys/modules/mly/Makefile
Normal 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>
|
Loading…
Reference in New Issue
Block a user