/*----------------------------------------------------------------------------
* Adapter_EIP93_Init
*/
bool
Adapter_EIP93_Init(void)
{
HWPAL_Device_t Device; //void*
EIP93_Status_t res93;
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_DISABLED;
if (!HWPAL_Device_Find("eip93", &Device))
{
LOG_CRIT("Adapter_EIP93_Init: Failed to find EIP93 device\n");
return false;
}
res93 = EIP93_Initialize(
&Adapter_EIP93_IOArea,
Device);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"EIP93_Initialize returned %d\n",
res93);
return false;
}
#ifdef ADAPTER_EIP93PE_INTERRUPTS_ENABLE
// Configure level of Interrupts
res93 = EIP93_INT_Configure(
&Adapter_EIP93_IOArea,
false,
false);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"EIP93_INT_Configure returned %d\n",
res93);
return false;
}
#endif // ADAPTER_EIP93PE_INTERRUPTS_ENABLE
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_IDLE;
return true;
}
/*----------------------------------------------------------------------------
* Adapter_EIP93_SetMode_DHM
*
* Return Value
* true Success
* false Failed
*/
bool
Adapter_EIP93_SetMode_DHM(void)
{
#ifndef ADAPTER_EIP93_PE_MODE_DHM
return false;
#else
EIP93_Status_t res93;
if (Adapter_EIP93_Mode == ADAPTER_EIP93_MODE_DHM)
{
LOG_CRIT("Adapter_EIP93_SetMode_DHM: Already in DHM Mode\n");
return true;
}
if (Adapter_EIP93_Mode != ADAPTER_EIP93_MODE_IDLE)
{
LOG_CRIT("Adapter_EIP93_SetMode_DHM: Not possible in mode %d\n",
Adapter_EIP93_Mode);
return false;
}
{
bool fEnableAutoSwapForRegisterData = false;
res93 = EIP93_DHM_Activate(
&Adapter_EIP93_IOArea,
ADAPTER_EIP93_DHM_THRESHOLD_INPUT,
ADAPTER_EIP93_DHM_THRESHOLD_OUTPUT,
fEnableAutoSwapForRegisterData);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"EIP93_DHM_Activate returned %d\n",
res93);
return false;
}
LOG_INFO("EIP93_DHM_Activate called \n");
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_DHM;
LOG_INFO("Adapter: Successfully initialized EIP93v2 in DHM mode\n");
}
return true;
#endif /* ADAPTER_EIP93_PE_MODE_DHM */
}
/*----------------------------------------------------------------------------
* Adapter_EIP93_UnInit
*/
void
Adapter_EIP93_UnInit(void)
{
EIP93_Status_t res93;
res93 = EIP93_Shutdown(&Adapter_EIP93_IOArea);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_UnInit: "
"EIP93_Shutdown returned %d\n",
res93);
}
if (Adapter_EIP93_Mode == ADAPTER_EIP93_MODE_ARM)
{
// free the ring memory blocks
DMABuf_Release(Adapter_EIP93_CmdRing_Handle);
#ifdef ADAPTER_EIP93_SEPARATE_RINGS
DMABuf_Release(Adapter_EIP93_ResRing_Handle);
#endif
}
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_DISABLED;
}
static void kill_squeal()
{
LOG_TRACE("Releasing networking");
/*if (event_base_loopexit(evbase_accept, NULL)) {
perror("Error shutting down server");
}*/
LOG_TRACE("Shutting down IO threads");
squeal_tp_destroy(server->pool);
LOG_TRACE("Freeing all resources");
squeal_config_free(server->config);
LOG_CRIT("Shutting down Squeal");
log_release();
}
static int
slad_test_fop_open (struct inode *inode, struct file *file)
{
unsigned int minor = iminor (inode);
if (minor <= SLAD_TEST_NO)
{
//LOG_CRIT ("slad_test_fop_open(); minor %d\n", minor);
return 0;
}
else
{
LOG_CRIT ("slad_test_fop_open(); BAD minor %d\n", minor);
return -1;
}
}
static ssize_t
slad_test_fop_cread (struct file *filp, char *buf, size_t count,
loff_t * ppos)
{
unsigned int minor = MINOR (filp->f_dentry->d_inode->i_rdev);
if (minor < SLAD_TEST_NO)
{
// LOG_CRIT ("slad_test_fop_cread(); so what?\n");
}
else
{
LOG_CRIT ("slad_test_fop_cread(); BAD minor %d\n", minor);
return -1;
}
return 1;
}
/*----------------------------------------------------------------------------
* Adapter_DHM_Work_Put
*
* This function takes the information in Adapter_DHM_Work and calls
* EIP93_DHM_Packet_Put. Remaining fields of the command descriptor not
* looked at by Adapter_DHM_Work_Fill are validated here.
*
* Returns PEC_STATUS_OK or one of PEC_ERROR_xxx.
*/
PEC_Status_t
Adapter_DHM_Work_Put(
const PEC_CommandDescriptor_t * const Cmd_p)
{
EIP93_DHM_CommandDescriptor_t CD = {0};
EIP93_Status_t res93;
if (Cmd_p->Bypass_WordCount > 255)
return PEC_ERROR_BAD_PARAMETER;
CD.BypassWordsCount = (uint8_t)Cmd_p->Bypass_WordCount;
CD.SrcPacketByteCount = Cmd_p->SrcPkt_ByteCount;
CD.ControlWord = Cmd_p->Control1;
CD.SARecord_p = Adapter_DHM_Work.SARecord_p;
CD.SARecordLength = Adapter_DHM_Work.SARecordLength;
CD.SAState_p = Adapter_DHM_Work.SAState_p;
CD.SAStateLength = Adapter_DHM_Work.SAStateLength;
CD.ARC4State_p = Adapter_DHM_Work.ARC4State_p;
CD.ARC4StateLength = Adapter_DHM_Work.ARC4StateLength;
LOG_INFO("Adapter_DHM: Calling EIP93_DHM_Packet_Put\n");
res93 = EIP93_DHM_Packet_Put(
&Adapter_EIP93_IOArea,
&CD);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"PEC_Packet_Put: "
"EIP93_DHM_Packet_Put returned %d\n",
res93);
return PEC_ERROR_INTERNAL;
}
return PEC_STATUS_OK;
}
/*----------------------------------------------------------------------------
* PEC_SA_Register
*
* SA_Handle1 = SA
* SA_Handle2 = State (optional)
* SA_Handle3 = ARC4 State (optional)
*/
PEC_Status_t
PEC_SA_Register(
DMABuf_Handle_t SA_Handle1,
DMABuf_Handle_t SA_Handle2,
DMABuf_Handle_t SA_Handle3)
{
IDENTIFIER_NOT_USED(&SA_Handle1 > &SA_Handle2);
IDENTIFIER_NOT_USED(&SA_Handle2 > &SA_Handle3);
LOG_INFO(
"PEC_SA_Register: "
"SA_Handle1,2,3 = %p, %p, %p\n",
SA_Handle1.p,
SA_Handle2.p,
SA_Handle3.p);
// reset the previous handles
Adapter_DHM_Work.SA_Handle = Adapter_DMABuf_NullHandle;
Adapter_DHM_Work.SA_State_Handle = Adapter_DMABuf_NullHandle;
Adapter_DHM_Work.SA_ARC4State_Handle = Adapter_DMABuf_NullHandle;
if (!Adapter_DMABuf_IsValidHandle(SA_Handle1))
return PEC_ERROR_BAD_HANDLE;
// accepted as the SA Handle
Adapter_DHM_Work.SA_Handle = SA_Handle1;
if (Adapter_DMABuf_IsValidHandle(SA_Handle2))
{
// make sure it is not identical to SA_Handle1
if (Adapter_DMABuf_IsSameHandle(&SA_Handle1, &SA_Handle2))
return PEC_ERROR_BAD_HANDLE;
// State record is of variable size, but depends on the SA format
// SA_Rev1: 10 words = 40 bytes
// SA_Rev2: 22 words = 88 bytes
// DynSA: 4, 18 or 22 bytes = 16, 72 or 88 bytes
// verify the buffer is large enough
// by checking it here, we can assume the fixed size in Packet_Put
{
HWPAL_DMAResource_Handle_t DMAHandle;
HWPAL_DMAResource_Record_t * DMARec_p;
DMAHandle = Adapter_DMABuf_Handle2DMAResourceHandle(SA_Handle2);
DMARec_p = HWPAL_DMAResource_Handle2RecordPtr(DMAHandle);
if (DMARec_p == NULL)
{
LOG_WARN(
"PEC_Register_SA: "
"Address look-up for SA_Handle2 failed\n");
return PEC_ERROR_BAD_HANDLE;
}
if (DMARec_p->host.BufferSize < 16)
{
LOG_CRIT(
"PEC_Register_SA: "
"Rejecting SA_Handle2 for State Record because size %d < 16\n",
DMARec_p->host.BufferSize);
return PEC_ERROR_BAD_HANDLE;
}
}
// accepted as the SA State Record buffer
Adapter_DHM_Work.SA_State_Handle = SA_Handle2;
}
if (Adapter_DMABuf_IsValidHandle(SA_Handle3))
{
// make sure it is not identical to SA_Handle1 or SA_Handle2
if (Adapter_DMABuf_IsSameHandle(&SA_Handle1, &SA_Handle3) ||
Adapter_DMABuf_IsSameHandle(&SA_Handle2, &SA_Handle3))
{
return PEC_ERROR_BAD_HANDLE;
}
// ARC4 State record is fixed size 256 bytes
// verify the buffer is large enough
// by checking it here, we can assume the fixed size in Packet_Put
{
HWPAL_DMAResource_Handle_t DMAHandle;
HWPAL_DMAResource_Record_t * DMARec_p;
DMAHandle = Adapter_DMABuf_Handle2DMAResourceHandle(SA_Handle3);
DMARec_p = HWPAL_DMAResource_Handle2RecordPtr(DMAHandle);
if (DMARec_p == NULL)
{
LOG_WARN(
"PEC_Register_SA: "
"Address look-up for SA_Handle3 failed\n");
return PEC_ERROR_BAD_HANDLE;
}
if (DMARec_p->host.BufferSize < 256)
{
LOG_CRIT(
"PEC_Register_SA: "
"Rejecting SA_Handle3 for ARC4 State because size %d < 256\n",
DMARec_p->host.BufferSize);
return PEC_ERROR_BAD_HANDLE;
}
}
// accept it as the SA ARC4 State buffer
Adapter_DHM_Work.SA_ARC4State_Handle = SA_Handle3;
}
// this call is not required, so we fake it is OK
return PEC_STATUS_OK;
}
/*----------------------------------------------------------------------------
* Adapter_EIP93_SetMode_Idle
*
* Return Value
* true Success
* false Failed
*/
bool
Adapter_EIP93_SetMode_Idle(void)
{
EIP93_Status_t res93 ;
switch (Adapter_EIP93_Mode)
{
case ADAPTER_EIP93_MODE_DISABLED:
// cannot use EIP93
return false;
case ADAPTER_EIP93_MODE_IDLE:
// already idle
return true;
case ADAPTER_EIP93_MODE_DHM:
res93 = EIP93_Deactivate(&Adapter_EIP93_IOArea);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_SetMode_Idle: "
"EIP93_Deactivate returned %d\n",
res93);
}
LOG_INFO("Adapter: Successfully deactivated EIP93 \n");
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_IDLE;
LOG_INFO("Adapter: Successfully deactivated EIP93 \n");
return true;
case ADAPTER_EIP93_MODE_ARM:
res93 = EIP93_Deactivate(&Adapter_EIP93_IOArea);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_SetMode_Idle: "
"EIP93_Deactivate returned %d\n",
res93);
}
// free the ring memory blocks
DMABuf_Release(Adapter_EIP93_CmdRing_Handle);
#ifdef ADAPTER_EIP93_SEPARATE_RINGS
DMABuf_Release(Adapter_EIP93_ResRing_Handle);
#endif
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_IDLE;
LOG_INFO("Adapter: Successfully deactivated EIP93v2\n");
return true;
default:
break;
} // switch
LOG_CRIT("Adapter_EIP93_SetMode_Idle: Unexpected mode %d\n",
Adapter_EIP93_Mode);
return false;
}
/*----------------------------------------------------------------------------
* Adapter_GetEIP93PhysAddr
*
* This routine checks if we have already translated the address for EIP93
* DMA. If not, we translate it now and cache it in the DMAResource Record.
* We then return the address.
*
* Handle
* Must be a valid handle.
*
* Return Value
* Physical address for the start of the buffer referred to by Handle,
* or zero if address translation was not possible.
*/
void
Adapter_GetEIP93PhysAddr(
DMABuf_Handle_t Handle,
HWPAL_DMAResource_Handle_t * const DMAHandle_p,
EIP93_DeviceAddress_t * const EIP93PhysAddr_p)
{
HWPAL_DMAResource_Handle_t DMAHandle;
HWPAL_DMAResource_Record_t * Rec_p = NULL;
if (EIP93PhysAddr_p == NULL)
{
LOG_CRIT("Adapter_GetEIP93PhysAddr: PANIC\n");
return;
}
// initialize the output parameters
if (DMAHandle_p)
*DMAHandle_p = NULL;
EIP93PhysAddr_p->Addr = 0;
EIP93PhysAddr_p->UpperAddr = 0;
if (!Adapter_DMABuf_IsValidHandle(Handle))
return;
{
// translate the handle
DMAHandle = Adapter_DMABuf_Handle2DMAResourceHandle(Handle);
// get the record belonging to this handle
Rec_p = HWPAL_DMAResource_Handle2RecordPtr(DMAHandle);
}
if (Rec_p == NULL)
return;
if (DMAHandle_p)
*DMAHandle_p = DMAHandle;
if (Rec_p->device.DeviceAddr32 > 1)
goto PHYS_DONE;
if (0 == Rec_p->device.DeviceAddr32)
{
// first time, so translate
AddrTrans_Pair_t PairIn;
AddrTrans_Pair_t PairOut;
AddrTrans_Status_t res;
// assume address translation will fail
Rec_p->device.DeviceAddr32 = 1;
// value used inside this function only
if (Rec_p->alloc.AllocatorRef == ADAPTER_DMABUF_ALLOCATORREF_KMALLOC)
{
// kmalloc-allocated buffer
// address translator needs to know this through alternative-ref
PairIn.Address_p = Rec_p->host.HostAddr_p;
PairIn.Domain = ADDRTRANS_DOMAIN_ALTERNATIVE;
res = AddrTrans_Translate(
PairIn,
ADAPTER_DMABUF_ALLOCATORREF_KMALLOC,
ADDRTRANS_DOMAIN_DEVICE_PE,
&PairOut);
if (res == ADDRTRANS_STATUS_OK)
{
// support for 32bit addresses only
// unsigned long will be 64bit only on 64bit systems
unsigned long Addr64or32 = (unsigned long)PairOut.Address_p;
unsigned long HighAddr = Addr64or32;
HighAddr >>= 16; // shift in two steps avoids
HighAddr >>= 16; // side-effect with failing 32bit shift
if (HighAddr)
{
LOG_CRIT(
"Adapter_EIP93: "
"Physical Address too > 4GB not supported!"
" (handle=%p)\n",
Handle.p);
return; // ## RETURN ##
}
Rec_p->device.DeviceAddr32 = (uint32_t)Addr64or32;
#ifdef ADAPTER_EIP93_ARMRING_ENABLE_SWAP
Rec_p->device.fSwapEndianess = true;
#endif
goto PHYS_DONE;
}
/*----------------------------------------------------------------------------
* Adapter_EIP93_SetMode_ARM
*
* Return Value
* true Success
* false Failed
*/
bool
Adapter_EIP93_SetMode_ARM(
const bool fEnableDynamicSA)
{
#ifndef ADAPTER_EIP93_PE_MODE_ARM
IDENTIFIER_NOT_USED(fEnableDynamicSA);
return false;
#else
EIP93_ARM_Settings_t Settings = {0};
EIP93_ARM_RingMemory_t RingMemory = {0};
EIP93_Status_t res93;
if (Adapter_EIP93_Mode != ADAPTER_EIP93_MODE_IDLE)
{
LOG_CRIT("Adapter_EIP93_SetMode_ARM: Not possible in mode %d\n",
Adapter_EIP93_Mode);
return false;
}
/**** allocate memory for the ring ****/
ZEROINIT(RingMemory);
// bytes to words conversion from ADAPTER_EIP93_RINGSIZE_BYTES
RingMemory.RingSizeInWords = Adapter_EIP93_RingProps.Size >> 2;
{
DMABuf_Status_t dmares;
DMABuf_HostAddress_t HostAddr;
dmares = DMABuf_Alloc(
Adapter_EIP93_RingProps,
&HostAddr,
&Adapter_EIP93_CmdRing_Handle);
if (dmares != DMABUF_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"DMABuf_Alloc (Command Ring) returned %d\n",
dmares);
return false;
}
LOG_INFO(
"Adapter_EIP93_Init: "
"CmdRing_Handle=%p\n",
Adapter_EIP93_CmdRing_Handle.p);
Adapter_GetEIP93PhysAddr(
Adapter_EIP93_CmdRing_Handle,
&RingMemory.CommandRingHandle,
&RingMemory.CommandRingAddr);
if (RingMemory.CommandRingAddr.Addr == 0)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"Failed to get command ring physical address\n");
// free the command ring memory
DMABuf_Release(Adapter_EIP93_CmdRing_Handle);
return false; // ## RETURN ##
}
}
#ifndef ADAPTER_EIP93_SEPARATE_RINGS
// not separate rings
RingMemory.fSeparateRings = false;
#else
// separat rings
RingMemory.fSeparateRings = true;
{
DMABuf_Status_t dmares;
DMABuf_HostAddress_t HostAddr;
dmares = DMABuf_Alloc(
Adapter_EIP93_RingProps,
&HostAddr,
&Adapter_EIP93_ResRing_Handle);
if (dmares != DMABUF_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"DMABuf_Alloc (Result Ring) returned %d\n",
dmares);
// free the command ring memory
DMABuf_Release(Adapter_EIP93_CmdRing_Handle);
return false;
}
LOG_INFO(
"Adapter_EIP93_Init: "
"ResRing_Handle=%p\n",
Adapter_EIP93_ResRing_Handle.p);
Adapter_GetEIP93PhysAddr(
Adapter_EIP93_ResRing_Handle,
&RingMemory.ResultRingHandle,
&RingMemory.ResultRingAddr);
if (RingMemory.ResultRingAddr.Addr == 0)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"Failed to get result ring physical address\n");
// free the ring memories
DMABuf_Release(Adapter_EIP93_CmdRing_Handle);
DMABuf_Release(Adapter_EIP93_ResRing_Handle);
return false;
}
}
#endif /* ADAPTER_EIP93_SEPARATE_RINGS */
// create the engine settings block
Settings.nPEInputThreshold = ADAPTER_EIP93_DMATHRESHOLD_INPUT;
Settings.nPEOutputThreshold = ADAPTER_EIP93_DMATHRESHOLD_OUTPUT;
Settings.nDescriptorDoneCount = ADAPTER_EIP93_DESCRIPTORDONECOUNT;
Settings.nDescriptorDoneTimeout = ADAPTER_EIP93_DESCRIPTORDONETIMEOUT;
Settings.nDescriptorPendingCount= ADAPTER_EIP93_DESCRIPTORPENDINGCOUNT;
Settings.nDescriptorSize = 8 ;
// Settings.nRingPollDivisor = ADAPTER_EIP93_RINGPOLLDIVISOR;
Adapter_EIP93_MaxDescriptorsInRing =
RingMemory.RingSizeInWords /
EIP93_ARM_DESCRIPTOR_SIZE();
res93 = EIP93_ARM_Activate(
&Adapter_EIP93_IOArea,
&Settings,
&RingMemory);
if (res93 != EIP93_STATUS_OK)
{
LOG_CRIT(
"Adapter_EIP93_Init: "
"EIP93_ARM_Activate returned %d\n",
res93);
// free the ring memory blocks
DMABuf_Release(Adapter_EIP93_CmdRing_Handle);
#ifdef ADAPTER_EIP93_SEPARATE_RINGS
DMABuf_Release(Adapter_EIP93_ResRing_Handle);
#endif
return false;
}
Adapter_EIP93_Mode = ADAPTER_EIP93_MODE_ARM;
LOG_INFO("Adapter: Successfully initialized EIP93v2 in ARM mode\n");
return true;
#endif /* ADAPTER_EIP93_PE_MODE_ARM */
}
static ssize_t
slad_test_fop_cwrite (struct file *filp, const char *buf,
size_t count,
loff_t * ppos)
{
unsigned int minor = MINOR (filp->f_dentry->d_inode->i_rdev);
SLAD_TEST_DRVCMD drvcmd = { 0 };
UINT32 st = 0;
osal_copy_from_app (TRUE, &drvcmd, (void *) buf,
sizeof (SLAD_TEST_DRVCMD));
if (minor < SLAD_TEST_NO)
{
switch (drvcmd.cmd)
{
case SLAD_TEST_CMD_CONFIGURE_PE:
#ifdef SLAD_TEST_BUILD_FOR_PE
st = _slad_test_configure_pe (TRUE, drvcmd.pe_confs); //will call PEC_Capabilities_Get & PEC_init (CDR/RDR are allocated and ARM mode is activated)
#endif
break;
case SLAD_TEST_CMD_CONFIGURE_PKA:
#if defined (SLAD_TEST_BUILD_FOR_EIP28PKA) || defined (SLAD_TEST_BUILD_FOR_EIP154PKA)
st = _slad_test_configure_pka (TRUE, drvcmd.pka_confs);
#endif
break;
case SLAD_TEST_CMD_CONFIGURE_RNG:
#ifdef SLAD_TEST_BUILD_FOR_RNG
st = _slad_test_configure_rng (TRUE, drvcmd.rng_confs);
#endif
break;
case SLAD_TEST_CMD_CONFIGURE_TEST:
#ifdef SLAD_TEST_BUILD_FOR_PE
st = _slad_test_configure_test (TRUE, drvcmd.test_confs);
#endif
break;
case SLAD_TEST_CMD_NOTE_TESTS_N_DEVICE:
st =
_slad_test_note_tests_n_device (TRUE,
drvcmd.test_device_params);
break;
case SLAD_TEST_CMD_NOTE_PE_TEST_RECORD:
#ifdef SLAD_TEST_BUILD_FOR_PE
st = _slad_test_note_pe_test_record (TRUE, drvcmd.pe_tr); //will call PEC_Capabilities_Get, PEC_SA_Register, PEC_Packet_Put, PEC_Packet_Get, PEC_SA_UnRegister, PEC_UnInit
#endif
break;
case SLAD_TEST_CMD_NOTE_PKA_RECORD:
#if defined (SLAD_TEST_BUILD_FOR_EIP28PKA) || defined (SLAD_TEST_BUILD_FOR_EIP154PKA)
st = _slad_test_note_pka_record (TRUE, drvcmd.pka_record, drvcmd.num_pka_pkts);
#endif
break;
case SLAD_TEST_CMD_NOTE_RNG_RECORD:
#ifdef SLAD_TEST_BUILD_FOR_RNG
st = _slad_test_note_rng_record (TRUE, drvcmd.rng_record);
#endif
break;
case SLAD_TEST_UNINIT_DEVICES:
#ifdef SLAD_TEST_BUILD_FOR_PE
st = slad_test_uninit_devices (); //will call PEC_UnInit
#endif
break;
default:
printk ("\n Invalid command \n");
st = SLAD_TEST_STAT_COMMAND_INVALID;
break;
}
drvcmd.status = st;
osal_copy_to_app (TRUE, (void *) buf, &drvcmd,
sizeof (SLAD_TEST_DRVCMD));
}
else
{
LOG_CRIT ("slad_test_fop_cwrite(); BAD minor %d\n", minor);
return -1;
}
return 1;
}
