/*
* IO_CORE.C - core routines for IO module
*/
#include <ndis.h>
#include <ndiswan.h>
#include <mydefs.h>
#include <mytypes.h>
#include <util.h>
#include <disp.h>
#include <adapter.h>
#include <idd.h>
#include <mtl.h>
#include <cm.h>
#include <trc.h>
#include <io.h>
#include <dgatlas.h>
#include <dgbrip.h>
extern DRIVER_BLOCK Pcimac;
/* store location for prev. ioctl handler */
extern NTSTATUS (*PrevIoctl)(DEVICE_OBJECT* DeviceObject, IRP* Irp);
/* ioctl filter */
NTSTATUS
PcimacIoctl(DEVICE_OBJECT *DeviceObject, IRP *Irp)
{
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS ini_exec_irp(IRP* irp, IO_STACK_LOCATION* irpsp);
/* must be an ioctl, else pass this one */
if ( irpSp->MajorFunction != IRP_MJ_DEVICE_CONTROL )
{
NdisReleaseSpinLock(&Pcimac.lock);
return(PrevIoctl(DeviceObject, Irp));
}
/* must be our own private ioctl code */
switch( irpSp->Parameters.DeviceIoControl.IoControlCode )
{
case IO_IOCTL_PCIMAC_EXEC:
case DIGI_ATLAS_IOCTL:
break;
}
/* one of our own, execute */
Irp->IoStatus.Information = 0L;
ExecIrp(Irp, irpSp);
/* complete irp */
Irp->IoStatus.Status = status;
IoSetCancelRoutine (Irp, NULL);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return(status);
}
/* execute ioctl irp */
NTSTATUS
ExecIrp(IRP *irp, IO_STACK_LOCATION *irpsp)
{
UCHAR *in_buf, *out_buf;
ULONG in_len, out_len;
NTSTATUS stat;
/* establish in/out buffers */
out_len = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
in_len = irpsp->Parameters.DeviceIoControl.InputBufferLength;
/* in/out length must be the same */
if ( in_len != out_len )
return(STATUS_UNSUCCESSFUL);
switch( irpsp->Parameters.DeviceIoControl.IoControlCode )
{
case IO_IOCTL_PCIMAC_EXEC:
out_buf = irp->UserBuffer;
in_buf = irp->AssociatedIrp.SystemBuffer;
/* copy in buffer into output buffer */
NdisMoveMemory(out_buf, in_buf, out_len);
/* execute command in place */
if ( (stat = io_execute((IO_CMD*)out_buf,irp)) == IO_E_PENDING)
/* event added pend irp */
return (STATUS_PENDING);
else
/* return success */
return(STATUS_SUCCESS);
break;
case DIGI_ATLAS_IOCTL:
{
PATLAS_PDU_HEADER Atlas;
//
// We need to decapsulate the DIGI_Opcode wrapper to get to
// the IO_CMD
//
out_buf = irp->AssociatedIrp.SystemBuffer;
in_buf = irp->AssociatedIrp.SystemBuffer;
Atlas = (PATLAS_PDU_HEADER)out_buf;
switch( Atlas->dwCommand )
{
case EnumAdapters:
{
ULONG n, m, NumberOfAdapters;
PDIGI_SYSTEM SystemInfo;
//
// We need to let Atlas know about all the adapters
// we are controlling.
//
SystemInfo = (PDIGI_SYSTEM)GET_PAYLOAD(Atlas);
NumberOfAdapters = EnumAdaptersInSystem();
for( n = 0, m = 0; n < NumberOfAdapters; n++ )
{
ADAPTER *Adapter = GetAdapterByIndex(n);
if( Adapter )
{
PDIGI_ADAPTER AtlasAdapterInfo;
AtlasAdapterInfo = &SystemInfo->Adapters[m];
AtlasAdapterInfo->dwMemoryAddress = Adapter->BaseMem;
if( Adapter->BaseMem )
AtlasAdapterInfo->dwMemoryRange = 0x4000;
else
AtlasAdapterInfo->dwMemoryRange = 0;
AtlasAdapterInfo->dwIOAddress = Adapter->BaseIO;
AtlasAdapterInfo->dwIORange = 8;
AtlasAdapterInfo->dwInterruptNumber = 0;
AtlasAdapterInfo->dwDMA = 0;
AtlasAdapterInfo->dwPersonalities = 1;
AtlasAdapterInfo->Personalities[0].dwPersonalityTag = DIGI_PERSONALITY_BRI;
AtlasAdapterInfo->Personalities[0].dwId = (DWORD)Adapter;
NdisMoveMemory( AtlasAdapterInfo->Personalities[0].szDesc,
Adapter->Name,
BRI_MAX_NAMELEN );
m++;
}
}
SystemInfo->dwAdapters = m;
irp->IoStatus.Information = out_len;
break;
} // end case EnumAdapters:
case BRIOldMethod:
{
PDIGI_OLD_METHOD OldMethodInfo;
OldMethodInfo = (PDIGI_OLD_METHOD)GET_PAYLOAD(Atlas);
//
// We decapsulate the Atlas stuff and feed through the
// old method of getting this information.
//
if( (stat = io_execute( &(OldMethodInfo->ioCmd),
irp )) == IO_E_PENDING )
/* event added pend irp */
return (STATUS_PENDING);
else
{
irp->IoStatus.Information = out_len;
return(STATUS_SUCCESS);
}
break;
}
}
break;
}
}
}
/* execute an io command */
INT
io_execute(IO_CMD *cmd, VOID *Irp_1)
{
IRP *Irp = (IRP*)Irp_1;
D_LOG(D_ENTRY, ("io_execute: entry, cmd: 0x%lx\n", cmd));
/* check signature & version */
if ( cmd->sig != IO_CMD_SIG )
return(IO_E_BADSIG);
if ( (cmd->ver_major != IO_VER_MAJOR) ||
(cmd->ver_minor != IO_VER_MINOR) )
return(IO_E_BADVER);
D_LOG(D_ALWAYS, ("io_execute: opcode: 0x%x, cm: 0x%lx, idd: 0x%lx\n", \
cmd->opcode, cmd->cm, cmd->idd));
D_LOG(D_ALWAYS, ("io_execute: args: 0x%x 0x%x 0x%x 0x%x\n", \
cmd->arg[0], cmd->arg[1], cmd->arg[2], cmd->arg[3]));
/* clear status, assume success */
cmd->status = IO_E_SUCC;
/* branch on opcode */
switch ( cmd->opcode )
{
case IO_CMD_ENUM_ADAPTERS :
cmd->status = IoEnumAdapter(cmd);
break;
case IO_CMD_ENUM_CM:
cmd->status = IoEnumCm(cmd);
break;
case IO_CMD_ENUM_IDD :
cmd->status = IoEnumIdd(cmd);
break;
case IO_CMD_TRC_RESET :
cmd->status = trc_control(cmd->idd,
TRC_OP_RESET, (ULONG)cmd->idd);
break;
case IO_CMD_TRC_STOP :
cmd->status = trc_control(cmd->idd,
TRC_OP_STOP, (ULONG)cmd->idd);
break;
case IO_CMD_TRC_START :
cmd->status = trc_control(cmd->idd,
TRC_OP_START, (ULONG)cmd->idd);
break;
case IO_CMD_TRC_SET_FILT :
cmd->status = trc_control(cmd->idd,
TRC_OP_SET_FILTER, cmd->arg[0]);
break;
case IO_CMD_IDD_RESET_AREA :
cmd->status = idd_reset_area(cmd->idd);
break;
case IO_CMD_IDD_GET_AREA :
cmd->status = idd_get_area(cmd->idd, cmd->arg[0], NULL, NULL);
break;
case IO_CMD_IDD_GET_STAT :
cmd->status = idd_get_area_stat(cmd->idd, &cmd->val.IddStat);
break;
case IO_CMD_TRC_CREATE:
cmd->status = trc_control(cmd->idd,
TRC_OP_CREATE, cmd->arg[0]);
break;
case IO_CMD_TRC_DESTROY:
cmd->status = trc_control(cmd->idd,
TRC_OP_DESTROY, cmd->arg[0]);
break;
case IO_CMD_TRC_GET_STAT :
cmd->status = trc_get_status(idd_get_trc(cmd->idd),
&cmd->val.trc_stat);
break;
case IO_CMD_TRC_GET_ENT :
cmd->status = trc_get_entry(idd_get_trc(cmd->idd),
cmd->arg[0], &cmd->val.trc_ent);
break;
case IO_CMD_DBG_LEVEL :
DigiDebugLevel = (INT)(cmd->arg[0]);
break;
case IO_CMD_DO_IDP_CMD:
DbgPrint("DoIdpCmd: Cmd: 0x%x\n", cmd->arg[0]);
if( cmd->idd && (( ((IDD*)cmd->idd)->btype != IDD_BT_DATAFIREU) &&
( ((IDD*)cmd->idd)->btype != IDD_BT_DATAFIREST) &&
( ((IDD*)cmd->idd)->btype != IDD_BT_DATAFIRE4ST)) )
{
switch (cmd->arg[0])
{
case GET_IDP_IO_VALUE:
cmd->val.IdpRaw.uc = IdpGetUByteIO(cmd->idd,
cmd->val.IdpRaw.us);
cmd->status = IO_E_SUCC;
break;
case GET_IDP_BUFFER:
IdpGetBuffer(cmd->idd,
cmd->val.IdpRaw.Bank,
cmd->val.IdpRaw.Page,
cmd->val.IdpRaw.Address,
cmd->val.IdpRaw.Length,
cmd->val.IdpRaw.Buffer);
cmd->status = IO_E_SUCC;
break;
case SET_IDP_IO_VALUE:
IdpPutUByteIO(cmd->idd,
(USHORT)cmd->val.IdpRaw.Address,
cmd->val.IdpRaw.uc);
cmd->status = IO_E_SUCC;
break;
case SET_IDP_BUFFER:
IdpPutBuffer(cmd->idd,
cmd->val.IdpRaw.Bank,
cmd->val.IdpRaw.Page,
cmd->val.IdpRaw.Address,
cmd->val.IdpRaw.Length,
cmd->val.IdpRaw.Buffer);
cmd->status = IO_E_SUCC;
break;
default:
cmd->status = IO_E_BADCMD;
break;
}
}
else
cmd->status = IO_E_BADIDD;
break;
case IO_CMD_DO_ADP_CMD:
if( cmd->idd && (( ((IDD*)cmd->idd)->btype == IDD_BT_DATAFIREU) ||
( ((IDD*)cmd->idd)->btype == IDD_BT_DATAFIREST) ||
( ((IDD*)cmd->idd)->btype == IDD_BT_DATAFIRE4ST)) )
{
switch (cmd->arg[0])
{
case GET_ADP_UCHAR:
cmd->val.AdpRaw.uc = AdpGetUByte(cmd->idd,
cmd->val.AdpRaw.Address);
cmd->status = IO_E_SUCC;
break;
case GET_ADP_USHORT:
cmd->val.AdpRaw.us = AdpGetUShort(cmd->idd,
cmd->val.AdpRaw.Address);
cmd->status = IO_E_SUCC;
break;
case GET_ADP_ULONG:
cmd->val.AdpRaw.ul = AdpGetULong(cmd->idd,
cmd->val.AdpRaw.Address);
cmd->status = IO_E_SUCC;
break;
case GET_ADP_BUFFER:
AdpGetBuffer(cmd->idd,
cmd->val.AdpRaw.Buffer,
cmd->val.AdpRaw.Address,
cmd->val.AdpRaw.Length
);
cmd->status = IO_E_SUCC;
break;
case SET_ADP_UCHAR:
AdpPutUByte(cmd->idd,
cmd->val.AdpRaw.Address,
cmd->val.AdpRaw.uc);
cmd->status = IO_E_SUCC;
break;
case SET_ADP_USHORT:
AdpPutUShort(cmd->idd,
cmd->val.AdpRaw.Address,
cmd->val.AdpRaw.us);
cmd->status = IO_E_SUCC;
break;
case SET_ADP_ULONG:
AdpPutULong(cmd->idd,
cmd->val.AdpRaw.Address,
cmd->val.AdpRaw.ul);
cmd->status = IO_E_SUCC;
break;
case SET_ADP_BUFFER:
AdpPutBuffer(cmd->idd,
cmd->val.AdpRaw.Address,
cmd->val.AdpRaw.Buffer,
cmd->val.AdpRaw.Length);
cmd->status = IO_E_SUCC;
break;
default:
cmd->status = IO_E_BADCMD;
break;
}
}
else
cmd->status = IO_E_BADIDD;
break;
default :
cmd->status = IO_E_BADCMD;
break;
}
/* return status code */
return((INT)cmd->status);
}
