716 lines
21 KiB
C
716 lines
21 KiB
C
|
|
/*-
|
|
* Copyright (c) 2006-2010 Adaptec, Inc.
|
|
* Copyright (c) 2010-2012 PMC-Sierra, Inc.
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*
|
|
* Debugging support.
|
|
*/
|
|
#include "opt_aacraid.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <machine/resource.h>
|
|
#include <machine/bus.h>
|
|
|
|
#include <dev/aacraid/aacraid_reg.h>
|
|
#include <sys/aac_ioctl.h>
|
|
#include <dev/aacraid/aacraid_var.h>
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/bus.h>
|
|
#include <sys/rman.h>
|
|
|
|
#include <machine/resource.h>
|
|
#include <machine/bus.h>
|
|
#include <machine/stdarg.h>
|
|
|
|
#include <dev/aacraid/aacraid_debug.h>
|
|
|
|
#ifdef AACRAID_DEBUG
|
|
/*
|
|
* Dump the command queue indices
|
|
*/
|
|
void
|
|
aacraid_print_queues(struct aac_softc *sc)
|
|
{
|
|
device_printf(sc->aac_dev, "AACQ_FREE %d/%d\n",
|
|
sc->aac_qstat[AACQ_FREE].q_length, sc->aac_qstat[AACQ_FREE].q_max);
|
|
device_printf(sc->aac_dev, "AACQ_READY %d/%d\n",
|
|
sc->aac_qstat[AACQ_READY].q_length,
|
|
sc->aac_qstat[AACQ_READY].q_max);
|
|
device_printf(sc->aac_dev, "AACQ_BUSY %d/%d\n",
|
|
sc->aac_qstat[AACQ_BUSY].q_length, sc->aac_qstat[AACQ_BUSY].q_max);
|
|
}
|
|
|
|
/*
|
|
* Print a FIB
|
|
*/
|
|
void
|
|
aacraid_print_fib(struct aac_softc *sc, struct aac_fib *fib, const char *caller)
|
|
{
|
|
if (fib == NULL) {
|
|
device_printf(sc->aac_dev,
|
|
"aac_print_fib called with NULL fib\n");
|
|
return;
|
|
}
|
|
device_printf(sc->aac_dev, "%s: FIB @ %p\n", caller, fib);
|
|
device_printf(sc->aac_dev, " XferState %b\n", fib->Header.XferState,
|
|
"\20"
|
|
"\1HOSTOWNED"
|
|
"\2ADAPTEROWNED"
|
|
"\3INITIALISED"
|
|
"\4EMPTY"
|
|
"\5FROMPOOL"
|
|
"\6FROMHOST"
|
|
"\7FROMADAP"
|
|
"\10REXPECTED"
|
|
"\11RNOTEXPECTED"
|
|
"\12DONEADAP"
|
|
"\13DONEHOST"
|
|
"\14HIGH"
|
|
"\15NORM"
|
|
"\16ASYNC"
|
|
"\17PAGEFILEIO"
|
|
"\20SHUTDOWN"
|
|
"\21LAZYWRITE"
|
|
"\22ADAPMICROFIB"
|
|
"\23BIOSFIB"
|
|
"\24FAST_RESPONSE"
|
|
"\25APIFIB\n");
|
|
device_printf(sc->aac_dev, " Command %d\n", fib->Header.Command);
|
|
device_printf(sc->aac_dev, " StructType %d\n",
|
|
fib->Header.StructType);
|
|
device_printf(sc->aac_dev, " Size %d\n", fib->Header.Size);
|
|
device_printf(sc->aac_dev, " SenderSize %d\n",
|
|
fib->Header.SenderSize);
|
|
device_printf(sc->aac_dev, " SenderAddress 0x%x\n",
|
|
fib->Header.SenderFibAddress);
|
|
device_printf(sc->aac_dev, " RcvrAddress 0x%x\n",
|
|
fib->Header.u.ReceiverFibAddress);
|
|
device_printf(sc->aac_dev, " Handle 0x%x\n",
|
|
fib->Header.Handle);
|
|
switch(fib->Header.Command) {
|
|
case ContainerCommand:
|
|
{
|
|
struct aac_blockread *br;
|
|
struct aac_blockwrite *bw;
|
|
struct aac_sg_table *sg;
|
|
int i;
|
|
|
|
br = (struct aac_blockread*)fib->data;
|
|
bw = (struct aac_blockwrite*)fib->data;
|
|
sg = NULL;
|
|
|
|
if (br->Command == VM_CtBlockRead) {
|
|
device_printf(sc->aac_dev,
|
|
" BlockRead: container %d 0x%x/%d\n",
|
|
br->ContainerId, br->BlockNumber,
|
|
br->ByteCount);
|
|
sg = &br->SgMap;
|
|
}
|
|
if (bw->Command == VM_CtBlockWrite) {
|
|
device_printf(sc->aac_dev,
|
|
" BlockWrite: container %d 0x%x/%d "
|
|
"(%s)\n", bw->ContainerId,
|
|
bw->BlockNumber, bw->ByteCount,
|
|
bw->Stable == CSTABLE ? "stable" :
|
|
"unstable");
|
|
sg = &bw->SgMap;
|
|
}
|
|
if (sg != NULL) {
|
|
device_printf(sc->aac_dev,
|
|
" %d s/g entries\n", sg->SgCount);
|
|
for (i = 0; i < sg->SgCount; i++)
|
|
device_printf(sc->aac_dev, " 0x%08x/%d\n",
|
|
sg->SgEntry[i].SgAddress,
|
|
sg->SgEntry[i].SgByteCount);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
device_printf(sc->aac_dev, " %16D\n", fib->data, " ");
|
|
device_printf(sc->aac_dev, " %16D\n", fib->data + 16, " ");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Describe an AIF we have received.
|
|
*/
|
|
void
|
|
aacraid_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
|
|
{
|
|
switch(aif->command) {
|
|
case AifCmdEventNotify:
|
|
device_printf(sc->aac_dev, "EventNotify(%d)\n", aif->seqNumber);
|
|
switch(aif->data.EN.type) {
|
|
case AifEnGeneric: /* Generic notification */
|
|
device_printf(sc->aac_dev, "(Generic) %.*s\n",
|
|
(int)sizeof(aif->data.EN.data.EG),
|
|
aif->data.EN.data.EG.text);
|
|
break;
|
|
case AifEnTaskComplete: /* Task has completed */
|
|
device_printf(sc->aac_dev, "(TaskComplete)\n");
|
|
break;
|
|
case AifEnConfigChange: /* Adapter configuration change
|
|
* occurred */
|
|
device_printf(sc->aac_dev, "(ConfigChange)\n");
|
|
break;
|
|
case AifEnContainerChange: /* Adapter specific container
|
|
* configuration change */
|
|
device_printf(sc->aac_dev, "(ContainerChange) "
|
|
"container %d,%d\n",
|
|
aif->data.EN.data.ECC.container[0],
|
|
aif->data.EN.data.ECC.container[1]);
|
|
break;
|
|
case AifEnDeviceFailure: /* SCSI device failed */
|
|
device_printf(sc->aac_dev, "(DeviceFailure) "
|
|
"handle %d\n",
|
|
aif->data.EN.data.EDF.deviceHandle);
|
|
break;
|
|
case AifEnMirrorFailover: /* Mirror failover started */
|
|
device_printf(sc->aac_dev, "(MirrorFailover) "
|
|
"container %d failed, "
|
|
"migrating from slice %d to %d\n",
|
|
aif->data.EN.data.EMF.container,
|
|
aif->data.EN.data.EMF.failedSlice,
|
|
aif->data.EN.data.EMF.creatingSlice);
|
|
break;
|
|
case AifEnContainerEvent: /* Significant container
|
|
* event */
|
|
device_printf(sc->aac_dev, "(ContainerEvent) "
|
|
"container %d event "
|
|
"%d\n", aif->data.EN.data.ECE.container,
|
|
aif->data.EN.data.ECE.eventType);
|
|
break;
|
|
case AifEnFileSystemChange: /* File system changed */
|
|
device_printf(sc->aac_dev, "(FileSystemChange)\n");
|
|
break;
|
|
case AifEnConfigPause: /* Container pause event */
|
|
device_printf(sc->aac_dev, "(ConfigPause)\n");
|
|
break;
|
|
case AifEnConfigResume: /* Container resume event */
|
|
device_printf(sc->aac_dev, "(ConfigResume)\n");
|
|
break;
|
|
case AifEnFailoverChange: /* Failover space assignment
|
|
* changed */
|
|
device_printf(sc->aac_dev, "(FailoverChange)\n");
|
|
break;
|
|
case AifEnRAID5RebuildDone: /* RAID5 rebuild finished */
|
|
device_printf(sc->aac_dev, "(RAID5RebuildDone)\n");
|
|
break;
|
|
case AifEnEnclosureManagement: /* Enclosure management event */
|
|
device_printf(sc->aac_dev, "(EnclosureManagement) "
|
|
"EMPID %d unit %d "
|
|
"event %d\n", aif->data.EN.data.EEE.empID,
|
|
aif->data.EN.data.EEE.unitID,
|
|
aif->data.EN.data.EEE.eventType);
|
|
break;
|
|
case AifEnBatteryEvent: /* Significant NV battery
|
|
* event */
|
|
device_printf(sc->aac_dev, "(BatteryEvent) %d "
|
|
"(state was %d, is %d\n",
|
|
aif->data.EN.data.EBE.transition_type,
|
|
aif->data.EN.data.EBE.current_state,
|
|
aif->data.EN.data.EBE.prior_state);
|
|
break;
|
|
case AifEnAddContainer: /* A new container was
|
|
* created. */
|
|
device_printf(sc->aac_dev, "(AddContainer)\n");
|
|
break;
|
|
case AifEnDeleteContainer: /* A container was deleted. */
|
|
device_printf(sc->aac_dev, "(DeleteContainer)\n");
|
|
break;
|
|
case AifEnBatteryNeedsRecond: /* The battery needs
|
|
* reconditioning */
|
|
device_printf(sc->aac_dev, "(BatteryNeedsRecond)\n");
|
|
break;
|
|
case AifEnClusterEvent: /* Some cluster event */
|
|
device_printf(sc->aac_dev, "(ClusterEvent) event %d\n",
|
|
aif->data.EN.data.ECLE.eventType);
|
|
break;
|
|
case AifEnDiskSetEvent: /* A disk set event occured. */
|
|
device_printf(sc->aac_dev, "(DiskSetEvent) event %d "
|
|
"diskset %jd creator %jd\n",
|
|
aif->data.EN.data.EDS.eventType,
|
|
(intmax_t)aif->data.EN.data.EDS.DsNum,
|
|
(intmax_t)aif->data.EN.data.EDS.CreatorId);
|
|
break;
|
|
case AifDenMorphComplete: /* A morph operation
|
|
* completed */
|
|
device_printf(sc->aac_dev, "(MorphComplete)\n");
|
|
break;
|
|
case AifDenVolumeExtendComplete: /* A volume expand operation
|
|
* completed */
|
|
device_printf(sc->aac_dev, "(VolumeExtendComplete)\n");
|
|
break;
|
|
default:
|
|
device_printf(sc->aac_dev, "(%d)\n", aif->data.EN.type);
|
|
break;
|
|
}
|
|
break;
|
|
case AifCmdJobProgress:
|
|
{
|
|
char *status;
|
|
switch(aif->data.PR[0].status) {
|
|
case AifJobStsSuccess:
|
|
status = "success"; break;
|
|
case AifJobStsFinished:
|
|
status = "finished"; break;
|
|
case AifJobStsAborted:
|
|
status = "aborted"; break;
|
|
case AifJobStsFailed:
|
|
status = "failed"; break;
|
|
case AifJobStsSuspended:
|
|
status = "suspended"; break;
|
|
case AifJobStsRunning:
|
|
status = "running"; break;
|
|
default:
|
|
status = "unknown status"; break;
|
|
}
|
|
|
|
device_printf(sc->aac_dev, "JobProgress (%d) - %s (%d, %d)\n",
|
|
aif->seqNumber, status,
|
|
aif->data.PR[0].currentTick,
|
|
aif->data.PR[0].finalTick);
|
|
switch(aif->data.PR[0].jd.type) {
|
|
case AifJobScsiZero: /* SCSI dev clear operation */
|
|
device_printf(sc->aac_dev, "(ScsiZero) handle %d\n",
|
|
aif->data.PR[0].jd.client.scsi_dh);
|
|
break;
|
|
case AifJobScsiVerify: /* SCSI device Verify operation
|
|
* NO REPAIR */
|
|
device_printf(sc->aac_dev, "(ScsiVerify) handle %d\n",
|
|
aif->data.PR[0].jd.client.scsi_dh);
|
|
break;
|
|
case AifJobScsiExercise: /* SCSI device Exercise
|
|
* operation */
|
|
device_printf(sc->aac_dev, "(ScsiExercise) handle %d\n",
|
|
aif->data.PR[0].jd.client.scsi_dh);
|
|
break;
|
|
case AifJobScsiVerifyRepair: /* SCSI device Verify operation
|
|
* WITH repair */
|
|
device_printf(sc->aac_dev,
|
|
"(ScsiVerifyRepair) handle %d\n",
|
|
aif->data.PR[0].jd.client.scsi_dh);
|
|
break;
|
|
case AifJobCtrZero: /* Container clear operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerZero) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
break;
|
|
case AifJobCtrCopy: /* Container copy operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerCopy) container %d to %d\n",
|
|
aif->data.PR[0].jd.client.container.src,
|
|
aif->data.PR[0].jd.client.container.dst);
|
|
break;
|
|
case AifJobCtrCreateMirror: /* Container Create Mirror
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerCreateMirror) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
/* XXX two containers? */
|
|
break;
|
|
case AifJobCtrMergeMirror: /* Container Merge Mirror
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerMergeMirror) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
/* XXX two containers? */
|
|
break;
|
|
case AifJobCtrScrubMirror: /* Container Scrub Mirror
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerScrubMirror) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
break;
|
|
case AifJobCtrRebuildRaid5: /* Container Rebuild Raid5
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerRebuildRaid5) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
break;
|
|
case AifJobCtrScrubRaid5: /* Container Scrub Raid5
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerScrubRaid5) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
break;
|
|
case AifJobCtrMorph: /* Container morph operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerMorph) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
/* XXX two containers? */
|
|
break;
|
|
case AifJobCtrPartCopy: /* Container Partition copy
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerPartCopy) container %d to "
|
|
"%d\n",
|
|
aif->data.PR[0].jd.client.container.src,
|
|
aif->data.PR[0].jd.client.container.dst);
|
|
break;
|
|
case AifJobCtrRebuildMirror: /* Container Rebuild Mirror
|
|
* operation */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerRebuildMirror) container "
|
|
"%d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
break;
|
|
case AifJobCtrCrazyCache: /* crazy cache */
|
|
device_printf(sc->aac_dev,
|
|
"(ContainerCrazyCache) container %d\n",
|
|
aif->data.PR[0].jd.client.container.src);
|
|
/* XXX two containers? */
|
|
break;
|
|
case AifJobFsCreate: /* File System Create
|
|
* operation */
|
|
device_printf(sc->aac_dev, "(FsCreate)\n");
|
|
break;
|
|
case AifJobFsVerify: /* File System Verify
|
|
* operation */
|
|
device_printf(sc->aac_dev, "(FsVerivy)\n");
|
|
break;
|
|
case AifJobFsExtend: /* File System Extend
|
|
* operation */
|
|
device_printf(sc->aac_dev, "(FsExtend)\n");
|
|
break;
|
|
case AifJobApiFormatNTFS: /* Format a drive to NTFS */
|
|
device_printf(sc->aac_dev, "(FormatNTFS)\n");
|
|
break;
|
|
case AifJobApiFormatFAT: /* Format a drive to FAT */
|
|
device_printf(sc->aac_dev, "(FormatFAT)\n");
|
|
break;
|
|
case AifJobApiUpdateSnapshot: /* update the read/write half
|
|
* of a snapshot */
|
|
device_printf(sc->aac_dev, "(UpdateSnapshot)\n");
|
|
break;
|
|
case AifJobApiFormatFAT32: /* Format a drive to FAT32 */
|
|
device_printf(sc->aac_dev, "(FormatFAT32)\n");
|
|
break;
|
|
case AifJobCtlContinuousCtrVerify: /* Adapter operation */
|
|
device_printf(sc->aac_dev, "(ContinuousCtrVerify)\n");
|
|
break;
|
|
default:
|
|
device_printf(sc->aac_dev, "(%d)\n",
|
|
aif->data.PR[0].jd.type);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case AifCmdAPIReport:
|
|
device_printf(sc->aac_dev, "APIReport (%d)\n", aif->seqNumber);
|
|
break;
|
|
case AifCmdDriverNotify:
|
|
device_printf(sc->aac_dev, "DriverNotify (%d)\n",
|
|
aif->seqNumber);
|
|
break;
|
|
default:
|
|
device_printf(sc->aac_dev, "AIF %d (%d)\n", aif->command,
|
|
aif->seqNumber);
|
|
break;
|
|
}
|
|
}
|
|
#endif /* AACRAID_DEBUG */
|
|
|
|
/*
|
|
* Debug flags to be put into the HBA flags field when initialized
|
|
*/
|
|
const unsigned long aacraid_debug_flags = /* Variable to setup with above flags. */
|
|
/* HBA_FLAGS_DBG_KERNEL_PRINT_B | */
|
|
HBA_FLAGS_DBG_FW_PRINT_B |
|
|
/* HBA_FLAGS_DBG_FUNCTION_ENTRY_B | */
|
|
HBA_FLAGS_DBG_FUNCTION_EXIT_B |
|
|
HBA_FLAGS_DBG_ERROR_B |
|
|
HBA_FLAGS_DBG_INIT_B |
|
|
/* HBA_FLAGS_DBG_OS_COMMANDS_B | */
|
|
/* HBA_FLAGS_DBG_SCAN_B | */
|
|
/* HBA_FLAGS_DBG_COALESCE_B | */
|
|
/* HBA_FLAGS_DBG_IOCTL_COMMANDS_B | */
|
|
/* HBA_FLAGS_DBG_SYNC_COMMANDS_B | */
|
|
HBA_FLAGS_DBG_COMM_B |
|
|
/* HBA_FLAGS_DBG_AIF_B | */
|
|
/* HBA_FLAGS_DBG_CSMI_COMMANDS_B | */
|
|
HBA_FLAGS_DBG_DEBUG_B |
|
|
/* HBA_FLAGS_DBG_FLAGS_MASK | */
|
|
0;
|
|
|
|
int aacraid_get_fw_debug_buffer(struct aac_softc *sc)
|
|
{
|
|
u_int32_t MonDriverBufferPhysAddrLow = 0;
|
|
u_int32_t MonDriverBufferPhysAddrHigh = 0;
|
|
u_int32_t MonDriverBufferSize = 0;
|
|
u_int32_t MonDriverHeaderSize = 0;
|
|
|
|
/*
|
|
* Get the firmware print buffer parameters from the firmware
|
|
* If the command was successful map in the address.
|
|
*/
|
|
if (!aacraid_sync_command(sc, AAC_MONKER_GETDRVPROP, 0, 0, 0, 0, NULL, NULL)) {
|
|
MonDriverBufferPhysAddrLow = AAC_GET_MAILBOX(sc, 1);
|
|
MonDriverBufferPhysAddrHigh = AAC_GET_MAILBOX(sc, 2);
|
|
MonDriverBufferSize = AAC_GET_MAILBOX(sc, 3);
|
|
MonDriverHeaderSize = AAC_GET_MAILBOX(sc, 4);
|
|
if (MonDriverBufferSize) {
|
|
unsigned long Offset = MonDriverBufferPhysAddrLow
|
|
- rman_get_start(sc->aac_regs_res1);
|
|
|
|
/*
|
|
* See if the address is already mapped in and if so set it up
|
|
* from the base address
|
|
*/
|
|
if ((MonDriverBufferPhysAddrHigh == 0) &&
|
|
(Offset + MonDriverBufferSize <
|
|
rman_get_size(sc->aac_regs_res1))) {
|
|
sc->DebugOffset = Offset;
|
|
sc->DebugHeaderSize = MonDriverHeaderSize;
|
|
sc->FwDebugBufferSize = MonDriverBufferSize;
|
|
sc->FwDebugFlags = 0;
|
|
sc->DebugFlags = aacraid_debug_flags;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The GET_DRIVER_BUFFER_PROPERTIES command failed
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
#define PRINT_TIMEOUT 250000 /* 1/4 second */
|
|
|
|
void aacraid_fw_printf(struct aac_softc *sc, unsigned long PrintFlags, const char * fmt, ...)
|
|
{
|
|
va_list args;
|
|
u_int32_t Count, i;
|
|
char PrintBuffer_P[PRINT_BUFFER_SIZE];
|
|
unsigned long PrintType;
|
|
|
|
PrintType = PrintFlags &
|
|
~(HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B);
|
|
if (((PrintType!=0) && (sc!=NULL) && ((sc->DebugFlags & PrintType)==0))
|
|
|| ((sc!=NULL) && (sc->DebugFlags
|
|
& (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B)) == 0))
|
|
return;
|
|
|
|
/*
|
|
* Set up parameters and call sprintf function to format the data
|
|
*/
|
|
va_start(args, fmt);
|
|
vsprintf(PrintBuffer_P, fmt, args);
|
|
va_end(args);
|
|
|
|
/*
|
|
* Make sure the HBA structure has been passed in for this section
|
|
*/
|
|
if ((sc != NULL) && (sc->FwDebugBufferSize)) {
|
|
/*
|
|
* If we are set up for a Firmware print
|
|
*/
|
|
if ((sc->DebugFlags & HBA_FLAGS_DBG_FW_PRINT_B)
|
|
&& ((PrintFlags
|
|
& (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B))
|
|
!= HBA_FLAGS_DBG_KERNEL_PRINT_B)) {
|
|
/*
|
|
* Make sure the string size is within boundaries
|
|
*/
|
|
Count = strlen(PrintBuffer_P);
|
|
if (Count > sc->FwDebugBufferSize)
|
|
Count = (u_int16_t)sc->FwDebugBufferSize;
|
|
|
|
/*
|
|
* Wait for no more than PRINT_TIMEOUT for the previous
|
|
* message length to clear (the handshake).
|
|
*/
|
|
for (i = 0; i < PRINT_TIMEOUT; ++i) {
|
|
if (!AAC_MEM1_GETREG4(sc,
|
|
sc->DebugOffset + FW_DEBUG_STR_LENGTH_OFFSET)) {
|
|
break;
|
|
}
|
|
DELAY(1);
|
|
}
|
|
|
|
/*
|
|
* If the Length is clear, copy over the message, the
|
|
* flags, and the length. Make sure the length is the
|
|
* last because that is the signal for the Firmware to
|
|
* pick it up.
|
|
*/
|
|
if (!AAC_MEM1_GETREG4(sc,
|
|
sc->DebugOffset + FW_DEBUG_STR_LENGTH_OFFSET)) {
|
|
for (i = 0; i < Count; ++i) {
|
|
AAC_MEM1_SETREG1(sc, sc->DebugOffset + sc->DebugHeaderSize + i,
|
|
PrintBuffer_P[i]);
|
|
}
|
|
AAC_MEM1_SETREG4(sc, sc->DebugOffset + FW_DEBUG_FLAGS_OFFSET,
|
|
sc->FwDebugFlags);
|
|
AAC_MEM1_SETREG4(sc, sc->DebugOffset + FW_DEBUG_STR_LENGTH_OFFSET,
|
|
Count);
|
|
} else
|
|
sc->DebugFlags &= ~HBA_FLAGS_DBG_FW_PRINT_B;
|
|
}
|
|
|
|
/*
|
|
* If the Kernel Debug Print flag is set, send it off to the
|
|
* Kernel debugger
|
|
*/
|
|
if ((sc->DebugFlags & HBA_FLAGS_DBG_KERNEL_PRINT_B)
|
|
&& ((PrintFlags
|
|
& (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B))
|
|
!= HBA_FLAGS_DBG_FW_PRINT_B)) {
|
|
if (sc->FwDebugFlags & FW_DEBUG_FLAGS_NO_HEADERS_B)
|
|
printf ("%s\n", PrintBuffer_P);
|
|
else
|
|
device_printf (sc->aac_dev, "%s\n", PrintBuffer_P);
|
|
}
|
|
|
|
} else {
|
|
/*
|
|
* No HBA structure passed in so it has to be for the Kernel Debugger
|
|
*/
|
|
if ((sc != NULL) && (sc->FwDebugFlags & FW_DEBUG_FLAGS_NO_HEADERS_B))
|
|
printf ("%s\n", PrintBuffer_P);
|
|
else if (sc != NULL)
|
|
device_printf (sc->aac_dev, "%s\n", PrintBuffer_P);
|
|
else
|
|
printf("%s\n", PrintBuffer_P);
|
|
}
|
|
}
|
|
|
|
void aacraid_fw_print_mem(struct aac_softc *sc, unsigned long PrintFlags, u_int8_t *Addr, int Count)
|
|
{
|
|
int Offset, i;
|
|
u_int32_t DebugFlags = 0;
|
|
char Buffer[100];
|
|
char *LineBuffer_P;
|
|
|
|
/*
|
|
* If we have an HBA structure, save off the flags and set the no
|
|
* headers flag so we don't have garbage between our lines of data
|
|
*/
|
|
if (sc != NULL) {
|
|
DebugFlags = sc->FwDebugFlags;
|
|
sc->FwDebugFlags |= FW_DEBUG_FLAGS_NO_HEADERS_B;
|
|
}
|
|
|
|
Offset = 0;
|
|
|
|
/*
|
|
* Loop through all the data
|
|
*/
|
|
while (Offset < Count) {
|
|
/*
|
|
* We will format each line into a buffer and then print out
|
|
* the entire line so set the pointer to the beginning of the
|
|
* buffer
|
|
*/
|
|
LineBuffer_P = Buffer;
|
|
|
|
/*
|
|
* Set up the address in HEX
|
|
*/
|
|
sprintf(LineBuffer_P, "\n%04x ", Offset);
|
|
LineBuffer_P += 6;
|
|
|
|
/*
|
|
* Set up 16 bytes in HEX format
|
|
*/
|
|
for (i = 0; i < 16; ++i) {
|
|
/*
|
|
* If we are past the count of data bytes to output,
|
|
* pad with blanks
|
|
*/
|
|
if ((Offset + i) >= Count)
|
|
sprintf (LineBuffer_P, " ");
|
|
else
|
|
sprintf (LineBuffer_P, "%02x ", Addr[Offset+i]);
|
|
LineBuffer_P += 3;
|
|
|
|
/*
|
|
* At the mid point we will put in a divider
|
|
*/
|
|
if (i == 7) {
|
|
sprintf (LineBuffer_P, "- ");
|
|
LineBuffer_P += 2;
|
|
}
|
|
}
|
|
/*
|
|
* Now do the same 16 bytes at the end of the line in ASCII
|
|
* format
|
|
*/
|
|
sprintf (LineBuffer_P, " ");
|
|
LineBuffer_P += 2;
|
|
for (i = 0; i < 16; ++i) {
|
|
/*
|
|
* If all data processed, OUT-O-HERE
|
|
*/
|
|
if ((Offset + i) >= Count)
|
|
break;
|
|
|
|
/*
|
|
* If this is a printable ASCII character, convert it
|
|
*/
|
|
if ((Addr[Offset+i] > 0x1F) && (Addr[Offset+i] < 0x7F))
|
|
sprintf (LineBuffer_P, "%c", Addr[Offset+i]);
|
|
else
|
|
sprintf (LineBuffer_P, ".");
|
|
++LineBuffer_P;
|
|
}
|
|
/*
|
|
* The line is now formatted, so print it out
|
|
*/
|
|
aacraid_fw_printf(sc, PrintFlags, "%s", Buffer);
|
|
|
|
/*
|
|
* Bump the offset by 16 for the next line
|
|
*/
|
|
Offset += 16;
|
|
|
|
}
|
|
|
|
/*
|
|
* Restore the saved off flags
|
|
*/
|
|
if (sc != NULL)
|
|
sc->FwDebugFlags = DebugFlags;
|
|
}
|
|
|