Page MenuHomeFreeBSD
Differential D23887 Diff 69164 sys/dev/aacraid/aacraid_cam.c

Changeset View

Standalone View

View Options

sys/dev/aacraid/aacraid_cam.c

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
#include <vm/vm.h> #include <vm/vm.h>
#include <vm/pmap.h> #include <vm/pmap.h>
#include <dev/aacraid/aacraid_reg.h> #include <dev/aacraid/aacraid_reg.h>
#include <sys/aac_ioctl.h> #include <sys/aac_ioctl.h>
#include <dev/aacraid/aacraid_debug.h> #include <dev/aacraid/aacraid_debug.h>
#include <dev/aacraid/aacraid_var.h> #include <dev/aacraid/aacraid_var.h>
#include <dev/aacraid/aacraid_endian.h>
#ifndef CAM_NEW_TRAN_CODE #ifndef CAM_NEW_TRAN_CODE
#define CAM_NEW_TRAN_CODE 1 #define CAM_NEW_TRAN_CODE 1
#endif #endif
#ifndef SVPD_SUPPORTED_PAGE_LIST #ifndef SVPD_SUPPORTED_PAGE_LIST
struct scsi_vpd_supported_page_list struct scsi_vpd_supported_page_list
{ {
▲ Show 20 Lines • Show All 332 Lines • ▼ Show 20 Lines fib->Header.XferState =
AAC_FIBSTATE_FROMHOST | AAC_FIBSTATE_FROMHOST |
AAC_FIBSTATE_REXPECTED | AAC_FIBSTATE_REXPECTED |
AAC_FIBSTATE_NORM | AAC_FIBSTATE_NORM |
AAC_FIBSTATE_ASYNC | AAC_FIBSTATE_ASYNC |
AAC_FIBSTATE_FAST_RESPONSE; AAC_FIBSTATE_FAST_RESPONSE;
if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE2) { if (sc->flags & AAC_FLAGS_NEW_COMM_TYPE2) {
struct aac_raw_io2 *raw; struct aac_raw_io2 *raw;
/* NOTE: LE conversion handled at aacraid_map_command_sg() */
raw = (struct aac_raw_io2 *)&fib->data[0]; raw = (struct aac_raw_io2 *)&fib->data[0];
bzero(raw, sizeof(struct aac_raw_io2)); bzero(raw, sizeof(struct aac_raw_io2));
fib->Header.Command = RawIo2; fib->Header.Command = RawIo2;
raw->strtBlkLow = (u_int32_t)blockno; raw->strtBlkLow = (u_int32_t)blockno;
raw->strtBlkHigh = (u_int32_t)(blockno >> 32); raw->strtBlkHigh = (u_int32_t)(blockno >> 32);
raw->byteCnt = cm->cm_datalen; raw->byteCnt = cm->cm_datalen;
raw->ldNum = ccb->ccb_h.target_id; raw->ldNum = ccb->ccb_h.target_id;
fib->Header.Size += sizeof(struct aac_raw_io2); fib->Header.Size += sizeof(struct aac_raw_io2);
cm->cm_sgtable = (struct aac_sg_table *)raw->sge; cm->cm_sgtable = (struct aac_sg_table *)raw->sge;
if (cm->cm_flags & AAC_CMD_DATAIN) if (cm->cm_flags & AAC_CMD_DATAIN)
raw->flags = RIO2_IO_TYPE_READ | RIO2_SG_FORMAT_IEEE1212; raw->flags = RIO2_IO_TYPE_READ | RIO2_SG_FORMAT_IEEE1212;
else else
raw->flags = RIO2_IO_TYPE_WRITE | RIO2_SG_FORMAT_IEEE1212; raw->flags = RIO2_IO_TYPE_WRITE | RIO2_SG_FORMAT_IEEE1212;
} else if (sc->flags & AAC_FLAGS_RAW_IO) { } else if (sc->flags & AAC_FLAGS_RAW_IO) {
struct aac_raw_io *raw; struct aac_raw_io *raw;
/* NOTE: LE conversion handled at aacraid_map_command_sg() */
raw = (struct aac_raw_io *)&fib->data[0]; raw = (struct aac_raw_io *)&fib->data[0];
bzero(raw, sizeof(struct aac_raw_io)); bzero(raw, sizeof(struct aac_raw_io));
fib->Header.Command = RawIo; fib->Header.Command = RawIo;
raw->BlockNumber = blockno; raw->BlockNumber = blockno;
raw->ByteCount = cm->cm_datalen; raw->ByteCount = cm->cm_datalen;
raw->ContainerId = ccb->ccb_h.target_id; raw->ContainerId = ccb->ccb_h.target_id;
fib->Header.Size += sizeof(struct aac_raw_io); fib->Header.Size += sizeof(struct aac_raw_io);
cm->cm_sgtable = (struct aac_sg_table *) cm->cm_sgtable = (struct aac_sg_table *)
&raw->SgMapRaw; &raw->SgMapRaw;
if (cm->cm_flags & AAC_CMD_DATAIN) if (cm->cm_flags & AAC_CMD_DATAIN)
raw->Flags = 1; raw->Flags = 1;
} else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) { } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) {
fib->Header.Command = ContainerCommand; fib->Header.Command = ContainerCommand;
if (cm->cm_flags & AAC_CMD_DATAIN) { if (cm->cm_flags & AAC_CMD_DATAIN) {
struct aac_blockread *br; struct aac_blockread *br;
br = (struct aac_blockread *)&fib->data[0]; br = (struct aac_blockread *)&fib->data[0];
br->Command = VM_CtBlockRead; br->Command = VM_CtBlockRead;
br->ContainerId = ccb->ccb_h.target_id; br->ContainerId = ccb->ccb_h.target_id;
br->BlockNumber = blockno; br->BlockNumber = blockno;
br->ByteCount = cm->cm_datalen; br->ByteCount = cm->cm_datalen;
aac_blockread_tole(br);
fib->Header.Size += sizeof(struct aac_blockread); fib->Header.Size += sizeof(struct aac_blockread);
cm->cm_sgtable = &br->SgMap; cm->cm_sgtable = &br->SgMap;
} else { } else {
struct aac_blockwrite *bw; struct aac_blockwrite *bw;
bw = (struct aac_blockwrite *)&fib->data[0]; bw = (struct aac_blockwrite *)&fib->data[0];
bw->Command = VM_CtBlockWrite; bw->Command = VM_CtBlockWrite;
bw->ContainerId = ccb->ccb_h.target_id; bw->ContainerId = ccb->ccb_h.target_id;
bw->BlockNumber = blockno; bw->BlockNumber = blockno;
bw->ByteCount = cm->cm_datalen; bw->ByteCount = cm->cm_datalen;
bw->Stable = CUNSTABLE; bw->Stable = CUNSTABLE;
aac_blockwrite_tole(bw);
fib->Header.Size += sizeof(struct aac_blockwrite); fib->Header.Size += sizeof(struct aac_blockwrite);
cm->cm_sgtable = &bw->SgMap; cm->cm_sgtable = &bw->SgMap;
} }
} else { } else {
fib->Header.Command = ContainerCommand64; fib->Header.Command = ContainerCommand64;
if (cm->cm_flags & AAC_CMD_DATAIN) { if (cm->cm_flags & AAC_CMD_DATAIN) {
struct aac_blockread64 *br; struct aac_blockread64 *br;
br = (struct aac_blockread64 *)&fib->data[0]; br = (struct aac_blockread64 *)&fib->data[0];
br->Command = VM_CtHostRead64; br->Command = VM_CtHostRead64;
br->ContainerId = ccb->ccb_h.target_id; br->ContainerId = ccb->ccb_h.target_id;
br->SectorCount = cm->cm_datalen/AAC_BLOCK_SIZE; br->SectorCount = cm->cm_datalen/AAC_BLOCK_SIZE;
br->BlockNumber = blockno; br->BlockNumber = blockno;
br->Pad = 0; br->Pad = 0;
br->Flags = 0; br->Flags = 0;
aac_blockread64_tole(br);
fib->Header.Size += sizeof(struct aac_blockread64); fib->Header.Size += sizeof(struct aac_blockread64);
cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64; cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64;
} else { } else {
struct aac_blockwrite64 *bw; struct aac_blockwrite64 *bw;
bw = (struct aac_blockwrite64 *)&fib->data[0]; bw = (struct aac_blockwrite64 *)&fib->data[0];
bw->Command = VM_CtHostWrite64; bw->Command = VM_CtHostWrite64;
bw->ContainerId = ccb->ccb_h.target_id; bw->ContainerId = ccb->ccb_h.target_id;
bw->SectorCount = cm->cm_datalen/AAC_BLOCK_SIZE; bw->SectorCount = cm->cm_datalen/AAC_BLOCK_SIZE;
bw->BlockNumber = blockno; bw->BlockNumber = blockno;
bw->Pad = 0; bw->Pad = 0;
bw->Flags = 0; bw->Flags = 0;
aac_blockwrite64_tole(bw);
fib->Header.Size += sizeof(struct aac_blockwrite64); fib->Header.Size += sizeof(struct aac_blockwrite64);
cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64; cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64;
} }
} }
aac_enqueue_ready(cm); aac_enqueue_ready(cm);
aacraid_startio(cm->cm_sc); aacraid_startio(cm->cm_sc);
} }
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Lines if (sc->aac_support_opt2 & AAC_SUPPORTED_POWER_MANAGEMENT) {
bzero(ccfg, sizeof (*ccfg) - CT_PACKET_SIZE); bzero(ccfg, sizeof (*ccfg) - CT_PACKET_SIZE);
ccfg->Command = VM_ContainerConfig; ccfg->Command = VM_ContainerConfig;
ccfg->CTCommand.command = CT_PM_DRIVER_SUPPORT; ccfg->CTCommand.command = CT_PM_DRIVER_SUPPORT;
ccfg->CTCommand.param[0] = (ss->how & SSS_START ? ccfg->CTCommand.param[0] = (ss->how & SSS_START ?
AAC_PM_DRIVERSUP_START_UNIT : AAC_PM_DRIVERSUP_START_UNIT :
AAC_PM_DRIVERSUP_STOP_UNIT); AAC_PM_DRIVERSUP_STOP_UNIT);
ccfg->CTCommand.param[1] = co->co_mntobj.ObjectId; ccfg->CTCommand.param[1] = co->co_mntobj.ObjectId;
ccfg->CTCommand.param[2] = 0; /* 1 - immediate */ ccfg->CTCommand.param[2] = 0; /* 1 - immediate */
aac_cnt_config_tole(ccfg);
if (aacraid_wait_command(cm) != 0 || if (aacraid_wait_command(cm) != 0 ||
*(u_int32_t *)&fib->data[0] != 0) { le32toh(*(u_int32_t *)&fib->data[0]) != 0) {
printf("Power Management: Error start/stop container %d\n", printf("Power Management: Error start/stop container %d\n",
co->co_mntobj.ObjectId); co->co_mntobj.ObjectId);
} }
aacraid_release_command(cm); aacraid_release_command(cm);
} }
ccb->ccb_h.status = CAM_REQ_CMP; ccb->ccb_h.status = CAM_REQ_CMP;
break; break;
} }
▲ Show 20 Lines • Show All 255 Lines • ▼ Show 20 Lines if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
srb->data_len = 0; srb->data_len = 0;
} }
srb->bus = camsc->inf->BusNumber - 1; /* Bus no. rel. to the card */ srb->bus = camsc->inf->BusNumber - 1; /* Bus no. rel. to the card */
srb->target = ccb->ccb_h.target_id; srb->target = ccb->ccb_h.target_id;
srb->lun = ccb->ccb_h.target_lun; srb->lun = ccb->ccb_h.target_lun;
srb->timeout = ccb->ccb_h.timeout; /* XXX */ srb->timeout = ccb->ccb_h.timeout; /* XXX */
srb->retry_limit = 0; srb->retry_limit = 0;
aac_srb_tole(srb);
cm->cm_complete = aac_cam_complete; cm->cm_complete = aac_cam_complete;
cm->cm_ccb = ccb; cm->cm_ccb = ccb;
cm->cm_timestamp = time_uptime; cm->cm_timestamp = time_uptime;
fib->Header.XferState = fib->Header.XferState =
AAC_FIBSTATE_HOSTOWNED | AAC_FIBSTATE_HOSTOWNED |
AAC_FIBSTATE_INITIALISED | AAC_FIBSTATE_INITIALISED |
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines
static void static void
aac_container_complete(struct aac_command *cm) aac_container_complete(struct aac_command *cm)
{ {
union ccb *ccb; union ccb *ccb;
u_int32_t status; u_int32_t status;
fwprintf(cm->cm_sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, ""); fwprintf(cm->cm_sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
ccb = cm->cm_ccb; ccb = cm->cm_ccb;
status = ((u_int32_t *)cm->cm_fib->data)[0]; status = le32toh(((u_int32_t *)cm->cm_fib->data)[0]);
if (cm->cm_flags & AAC_CMD_RESET) { if (cm->cm_flags & AAC_CMD_RESET) {
ccb->ccb_h.status = CAM_SCSI_BUS_RESET; ccb->ccb_h.status = CAM_SCSI_BUS_RESET;
} else if (status == ST_OK) { } else if (status == ST_OK) {
ccb->ccb_h.status = CAM_REQ_CMP; ccb->ccb_h.status = CAM_REQ_CMP;
} else if (status == ST_NOT_READY) { } else if (status == ST_NOT_READY) {
ccb->ccb_h.status = CAM_BUSY; ccb->ccb_h.status = CAM_BUSY;
} else { } else {
Show All 10 Linesaac_cam_complete(struct aac_command *cm)
union ccb *ccb; union ccb *ccb;
struct aac_srb_response *srbr; struct aac_srb_response *srbr;
struct aac_softc *sc; struct aac_softc *sc;
sc = cm->cm_sc; sc = cm->cm_sc;
fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, ""); fwprintf(sc, HBA_FLAGS_DBG_FUNCTION_ENTRY_B, "");
ccb = cm->cm_ccb; ccb = cm->cm_ccb;
srbr = (struct aac_srb_response *)&cm->cm_fib->data[0]; srbr = (struct aac_srb_response *)&cm->cm_fib->data[0];
aac_srb_response_toh(srbr);
if (cm->cm_flags & AAC_CMD_FASTRESP) { if (cm->cm_flags & AAC_CMD_FASTRESP) {
/* fast response */ /* fast response */
srbr->srb_status = CAM_REQ_CMP; srbr->srb_status = CAM_REQ_CMP;
srbr->scsi_status = SCSI_STATUS_OK; srbr->scsi_status = SCSI_STATUS_OK;
srbr->sense_len = 0; srbr->sense_len = 0;
} }
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linesaac_cam_reset_bus(struct cam_sim *sim, union ccb *ccb)
vmi->Command = VM_Ioctl; vmi->Command = VM_Ioctl;
vmi->ObjType = FT_DRIVE; vmi->ObjType = FT_DRIVE;
vmi->MethId = sc->scsi_method_id; vmi->MethId = sc->scsi_method_id;
vmi->ObjId = 0; vmi->ObjId = 0;
vmi->IoctlCmd = ResetBus; vmi->IoctlCmd = ResetBus;
rbc = (struct aac_resetbus *)&vmi->IoctlBuf[0]; rbc = (struct aac_resetbus *)&vmi->IoctlBuf[0];
rbc->BusNumber = camsc->inf->BusNumber - 1; rbc->BusNumber = camsc->inf->BusNumber - 1;
aac_vmioctl_tole(vmi);
if (aacraid_wait_command(cm) != 0) { if (aacraid_wait_command(cm) != 0) {
device_printf(sc->aac_dev,"Error sending ResetBus command\n"); device_printf(sc->aac_dev,"Error sending ResetBus command\n");
rval = CAM_REQ_ABORTED; rval = CAM_REQ_ABORTED;
} else { } else {
rval = CAM_REQ_CMP; rval = CAM_REQ_CMP;
} }
aacraid_release_command(cm); aacraid_release_command(cm);
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines