static void
rge_chip_poke_reg(rge_t *rgep, rge_peekpoke_t *ppd)
{
uint64_t regval;
void *regaddr;
RGE_TRACE(("rge_chip_poke_reg($%p, $%p)",
(void *)rgep, (void *)ppd));
regaddr = PIO_ADDR(rgep, ppd->pp_acc_offset);
regval = ppd->pp_acc_data;
switch (ppd->pp_acc_size) {
case 1:
ddi_put8(rgep->io_handle, regaddr, regval);
break;
case 2:
ddi_put16(rgep->io_handle, regaddr, regval);
break;
case 4:
ddi_put32(rgep->io_handle, regaddr, regval);
break;
case 8:
ddi_put64(rgep->io_handle, regaddr, regval);
break;
}
}
void
pci_config_putll(ddi_acc_handle_t handle, off_t offset, uint64_t value)
{
caddr_t cfgaddr;
ddi_acc_hdl_t *hp;
hp = impl_acc_hdl_get(handle);
cfgaddr = hp->ah_addr + offset;
ddi_put64(handle, (uint64_t *)cfgaddr, value);
}
void
t4_write_reg64(struct adapter *sc, uint32_t reg, uint64_t val)
{
/* LINTED: E_BAD_PTR_CAST_ALIGN */
ddi_put64(sc->regh, (uint64_t *)(sc->regp + reg), val);
}
/*
* RAID Action for System Shutdown. This request uses the dedicated TM slot to
* avoid a call to mptsas_save_cmd. Since Solaris requires that the mutex is
* not held during the mptsas_quiesce function, this RAID action must not use
* the normal code path of requests and replies.
*/
void
mptsas_raid_action_system_shutdown(mptsas_t *mpt)
{
pMpi2RaidActionRequest_t action;
uint8_t ir_active = FALSE, reply_type;
uint8_t function, found_reply = FALSE;
uint16_t SMID, action_type;
mptsas_slots_t *slots = mpt->m_active;
int config, vol;
mptsas_cmd_t *cmd;
uint32_t request_desc_low, reply_addr;
int cnt;
pMpi2ReplyDescriptorsUnion_t reply_desc_union;
pMPI2DefaultReply_t reply;
pMpi2AddressReplyDescriptor_t address_reply;
/*
* Before doing the system shutdown RAID Action, make sure that the IOC
* supports IR and make sure there is a valid volume for the request.
*/
if (mpt->m_ir_capable) {
for (config = 0; (config < slots->m_num_raid_configs) &&
(!ir_active); config++) {
for (vol = 0; vol < MPTSAS_MAX_RAIDVOLS; vol++) {
if (slots->m_raidconfig[config].m_raidvol[vol].
m_israid) {
ir_active = TRUE;
break;
}
}
}
}
if (!ir_active) {
return;
}
/*
* If TM slot is already being used (highly unlikely), show message and
* don't issue the RAID action.
*/
if (slots->m_slot[MPTSAS_TM_SLOT(mpt)] != NULL) {
mptsas_log(mpt, CE_WARN, "RAID Action slot in use. Cancelling"
" System Shutdown RAID Action.\n");
return;
}
/*
* Create the cmd and put it in the dedicated TM slot.
*/
cmd = &(mpt->m_event_task_mgmt.m_event_cmd);
bzero((caddr_t)cmd, sizeof (*cmd));
cmd->cmd_pkt = NULL;
cmd->cmd_slot = MPTSAS_TM_SLOT(mpt);
slots->m_slot[MPTSAS_TM_SLOT(mpt)] = cmd;
/*
* Form message for raid action.
*/
action = (pMpi2RaidActionRequest_t)(mpt->m_req_frame +
(mpt->m_req_frame_size * cmd->cmd_slot));
bzero(action, mpt->m_req_frame_size);
action->Function = MPI2_FUNCTION_RAID_ACTION;
action->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
/*
* Send RAID Action.
*/
(void) ddi_dma_sync(mpt->m_dma_req_frame_hdl, 0, 0,
DDI_DMA_SYNC_FORDEV);
request_desc_low = (cmd->cmd_slot << 16) +
MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
MPTSAS_START_CMD(mpt, request_desc_low, 0);
/*
* Even though reply does not matter because the system is shutting
* down, wait no more than 5 seconds here to get the reply just because
* we don't want to leave it hanging if it's coming. Poll because
* interrupts are disabled when this function is called.
*/
for (cnt = 0; cnt < 5000; cnt++) {
/*
* Check for a reply.
*/
(void) ddi_dma_sync(mpt->m_dma_post_queue_hdl, 0, 0,
DDI_DMA_SYNC_FORCPU);
reply_desc_union = (pMpi2ReplyDescriptorsUnion_t)
MPTSAS_GET_NEXT_REPLY(mpt, mpt->m_post_index);
if (ddi_get32(mpt->m_acc_post_queue_hdl,
&reply_desc_union->Words.Low) == 0xFFFFFFFF ||
ddi_get32(mpt->m_acc_post_queue_hdl,
&reply_desc_union->Words.High) == 0xFFFFFFFF) {
drv_usecwait(1000);
continue;
}
/*
* There is a reply. If it's not an address reply, ignore it.
*/
reply_type = ddi_get8(mpt->m_acc_post_queue_hdl,
&reply_desc_union->Default.ReplyFlags);
reply_type &= MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
if (reply_type != MPI2_RPY_DESCRIPT_FLAGS_ADDRESS_REPLY) {
goto clear_and_continue;
}
/*
* SMID must be the TM slot since that's what we're using for
* this RAID action. If not, ignore this reply.
*/
address_reply =
(pMpi2AddressReplyDescriptor_t)reply_desc_union;
SMID = ddi_get16(mpt->m_acc_post_queue_hdl,
&address_reply->SMID);
if (SMID != MPTSAS_TM_SLOT(mpt)) {
goto clear_and_continue;
}
/*
* If reply frame is not in the proper range ignore it.
*/
reply_addr = ddi_get32(mpt->m_acc_post_queue_hdl,
&address_reply->ReplyFrameAddress);
if ((reply_addr < mpt->m_reply_frame_dma_addr) ||
(reply_addr >= (mpt->m_reply_frame_dma_addr +
(mpt->m_reply_frame_size * mpt->m_free_queue_depth))) ||
((reply_addr - mpt->m_reply_frame_dma_addr) %
mpt->m_reply_frame_size != 0)) {
goto clear_and_continue;
}
/*
* If not a RAID action reply ignore it.
*/
(void) ddi_dma_sync(mpt->m_dma_reply_frame_hdl, 0, 0,
DDI_DMA_SYNC_FORCPU);
reply = (pMPI2DefaultReply_t)(mpt->m_reply_frame +
(reply_addr - mpt->m_reply_frame_dma_addr));
function = ddi_get8(mpt->m_acc_reply_frame_hdl,
&reply->Function);
if (function != MPI2_FUNCTION_RAID_ACTION) {
goto clear_and_continue;
}
/*
* Finally, make sure this is the System Shutdown RAID action.
* If not, ignore reply.
*/
action_type = ddi_get16(mpt->m_acc_reply_frame_hdl,
&reply->FunctionDependent1);
if (action_type !=
MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED) {
goto clear_and_continue;
}
found_reply = TRUE;
clear_and_continue:
/*
* Clear the reply descriptor for re-use and increment index.
*/
ddi_put64(mpt->m_acc_post_queue_hdl,
&((uint64_t *)(void *)mpt->m_post_queue)[mpt->m_post_index],
0xFFFFFFFFFFFFFFFF);
(void) ddi_dma_sync(mpt->m_dma_post_queue_hdl, 0, 0,
DDI_DMA_SYNC_FORDEV);
/*
* Update the global reply index and keep looking for the
* reply if not found yet.
*/
if (++mpt->m_post_index == mpt->m_post_queue_depth) {
mpt->m_post_index = 0;
}
ddi_put32(mpt->m_datap, &mpt->m_reg->ReplyPostHostIndex,
mpt->m_post_index);
if (!found_reply) {
continue;
}
break;
}
/*
* clear the used slot as the last step.
*/
slots->m_slot[MPTSAS_TM_SLOT(mpt)] = NULL;
}
