SAT_returnState hk_app(tc_tm_pkt *pkt) {
if(!C_ASSERT(pkt != NULL && pkt->data != NULL) == true) { return SATR_ERROR; }
if(!C_ASSERT(pkt->ser_subtype == TC_HK_REPORT_PARAMETERS ||
pkt->ser_subtype == TM_HK_PARAMETERS_REPORT) == true) {return SATR_ERROR; }
if(pkt->ser_subtype == TC_HK_REPORT_PARAMETERS) {
tc_tm_pkt *temp_pkt = 0;
HK_struct_id sid = (HK_struct_id)pkt->data[0];
hk_crt_empty_pkt_TM(&temp_pkt, (TC_TM_app_id)pkt->dest_id, sid);
if(!C_ASSERT(temp_pkt != NULL) == true) {
return SATR_ERROR;
}
route_pkt(temp_pkt);
} else if(pkt->ser_subtype == TM_HK_PARAMETERS_REPORT) {
const SAT_returnState res = hk_parameters_report(pkt->app_id, (HK_struct_id)pkt->data[0], pkt->data, pkt->len);
if(res == SATR_OK) {
pkt->verification_state = SATR_OK;
}
}
return SATR_OK;
}
HRESULT GetImageInfoFromPEHeader( HANDLE hProcess, void* dllBase, uint16_t& machine, uint32_t& size, Address& prefBase )
{
IMAGE_DOS_HEADER dosHeader = { 0 };
SIZE_T cActual = 0;
if ( !::ReadProcessMemory( hProcess, dllBase, &dosHeader, sizeof dosHeader, &cActual ) )
{
_ASSERT( !"Failed to read IMAGE_DOS_HEADER from loaded module" );
return GetLastHr();
}
IMAGE_NT_HEADERS ntHeaders = { 0 };
void* ntHeadersAddr = (void*) ((DWORD_PTR) dosHeader.e_lfanew + (DWORD_PTR) dllBase);
if ( !::ReadProcessMemory( hProcess, ntHeadersAddr, &ntHeaders, sizeof ntHeaders, &cActual ) )
{
_ASSERT( !"Failed to read IMAGE_NT_HEADERS from loaded module" );
return GetLastHr();
}
// These fields line up for 32 and 64-bit IMAGE_NT_HEADERS; make sure of it
// otherwise, we would have had to check fileHeader.Characteristics & IMAGE_FILE_32BIT_MACHINE
C_ASSERT( &((IMAGE_NT_HEADERS32*) 0)->OptionalHeader.SizeOfImage ==
&((IMAGE_NT_HEADERS64*) 0)->OptionalHeader.SizeOfImage );
C_ASSERT( &((IMAGE_NT_HEADERS32*) 0)->FileHeader.Machine ==
&((IMAGE_NT_HEADERS64*) 0)->FileHeader.Machine );
machine = ntHeaders.FileHeader.Machine;
size = ntHeaders.OptionalHeader.SizeOfImage;
prefBase = ntHeaders.OptionalHeader.ImageBase;
return S_OK;
}
PmReturn_t
seqiter_new(pPmObj_t pobj, pPmObj_t *r_pobj)
{
PmReturn_t retval;
uint8_t *pchunk;
pPmSeqIter_t psi;
C_ASSERT(pobj != C_NULL);
C_ASSERT(*r_pobj != C_NULL);
/* Raise a TypeError if pobj is not a sequence */
if ((OBJ_GET_TYPE(pobj) != OBJ_TYPE_STR)
&& (OBJ_GET_TYPE(pobj) != OBJ_TYPE_TUP)
&& (OBJ_GET_TYPE(pobj) != OBJ_TYPE_LST))
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Alloc a chunk for the sequence iterator obj */
retval = heap_getChunk(sizeof(PmSeqIter_t), &pchunk);
PM_RETURN_IF_ERROR(retval);
/* Set the sequence iterator's fields */
psi = (pPmSeqIter_t)pchunk;
OBJ_SET_TYPE(psi, OBJ_TYPE_SQI);
psi->si_sequence = pobj;
psi->si_index = 0;
*r_pobj = (pPmObj_t)psi;
return retval;
}
PmReturn_t
seqiter_getNext(pPmObj_t pobj, pPmObj_t *r_pitem)
{
PmReturn_t retval;
int16_t length;
C_ASSERT(pobj != C_NULL);
C_ASSERT(*r_pitem != C_NULL);
C_ASSERT(OBJ_GET_TYPE(pobj) == OBJ_TYPE_SQI);
/*
* Raise TypeError if sequence iterator's object is not a sequence
* otherwise, the get sequence's length
*/
retval = seq_getLength(((pPmSeqIter_t)pobj)->si_sequence, &length);
PM_RETURN_IF_ERROR(retval);
/* Raise StopIteration if at the end of the sequence */
if (((pPmSeqIter_t)pobj)->si_index == length)
{
/* Make null the pointer to the sequence */
((pPmSeqIter_t)pobj)->si_sequence = C_NULL;
PM_RAISE(retval, PM_RET_EX_STOP);
return retval;
}
/* Get the item at the current index */
retval = seq_getSubscript(((pPmSeqIter_t)pobj)->si_sequence,
((pPmSeqIter_t)pobj)->si_index, r_pitem);
/* Increment the index */
((pPmSeqIter_t)pobj)->si_index++;
return retval;
}
// driver entry
NTSTATUS DriverEntry(__in PDRIVER_OBJECT pDriverObject,__in PUNICODE_STRING pRegPath)
{
PAGED_CODE();
C_ASSERT(sizeof(CHidData) == 0x6c);
C_ASSERT(sizeof(CDeviceExtension) == 0x200);
NTSTATUS statusRet = STATUS_SUCCESS;
AppleDebugPrint(DBGLEVEL_INFO,"Enter AppleKeyboard DriverEntry %p,%p\n",pDriverObject,pRegPath);
pDriverObject->MajorFunction[IRP_MJ_CREATE] = AppleKeyboardCreate;
pDriverObject->MajorFunction[IRP_MJ_CLOSE] = AppleKeyboardClose;
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AppleKeyboardIoControl;
pDriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = AppleKeyboardInternalIoControl;
pDriverObject->MajorFunction[IRP_MJ_PNP] = AppleKeyboardPnp;
pDriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = AppleKeyboardFlush;
pDriverObject->MajorFunction[IRP_MJ_POWER] = AppleKeyboardPower;
pDriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = AppleKeyboardSystemControl;
pDriverObject->DriverUnload = AppleKeyboardUnload;
pDriverObject->DriverExtension->AddDevice = AppleKeyboardAddDevice;
g_regPath.Length = pRegPath->Length;
g_regPath.MaximumLength = g_regPath.Length + sizeof(WCHAR);
g_regPath.Buffer = static_cast<PWCH>(ExAllocatePoolWithTag(PagedPool,g_regPath.MaximumLength,'Appl'));
if(g_regPath.Buffer)
RtlCopyMemory(g_regPath.Buffer,pRegPath->Buffer,pRegPath->Length);
else
statusRet = STATUS_INSUFFICIENT_RESOURCES;
AppleDebugPrint(DBGLEVEL_INFO,"Leave DriverEntry 0x%08x\n",statusRet);
return statusRet;
}
PmReturn_t
float_print(pPmObj_t pf)
{
uint8_t tBuffer[32];
uint8_t bytesWritten;
uint8_t i;
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pf != C_NULL);
/* Raise TypeError if obj is not an float */
if (OBJ_GET_TYPE(pf) != OBJ_TYPE_FLT)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* #196: Changed to use snprintf */
bytesWritten = snprintf((char *)&tBuffer, 32, "%f", ((pPmFloat_t) pf)->val);
/* Sanity check */
C_ASSERT(bytesWritten != 0);
C_ASSERT(bytesWritten < sizeof(tBuffer));
for (i = (uint8_t)0; i < bytesWritten; i++)
{
retval = plat_putByte(tBuffer[i]);
PM_RETURN_IF_ERROR(retval);
}
return PM_RET_OK;
}
// Helper method for updating an interface dispatch cache entry atomically. See comments by the usage of
// this method for the details of why we need this. If a racing update is detected false is returned and the
// update abandoned. This is necessary since it's not safe to update a valid cache entry (one with a non-NULL
// m_pInstanceType field) outside of a GC.
static bool UpdateCacheEntryAtomically(InterfaceDispatchCacheEntry *pEntry,
EEType * pInstanceType,
void * pTargetCode)
{
C_ASSERT(sizeof(InterfaceDispatchCacheEntry) == (sizeof(void*) * 2));
C_ASSERT(offsetof(InterfaceDispatchCacheEntry, m_pInstanceType) < offsetof(InterfaceDispatchCacheEntry, m_pTargetCode));
return UpdatePointerPairAtomically(pEntry, pInstanceType, pTargetCode, true) == NULL;
}
static
int32_t
IDNA_FlagsToICU
(
DWORD dwFlags
)
{
C_ASSERT(IDN_ALLOW_UNASSIGNED == UIDNA_ALLOW_UNASSIGNED);
C_ASSERT(IDN_USE_STD3_ASCII_RULES == UIDNA_USE_STD3_RULES);
return dwFlags;
}
PmReturn_t
thread_new(pPmObj_t pframe, pPmObj_t *r_pobj)
{
PmReturn_t retval = PM_RET_OK;
pPmThread_t pthread = C_NULL;
C_ASSERT(pframe != C_NULL);
/* If it's not a frame, raise TypeError */
if (OBJ_GET_TYPE(pframe) != OBJ_TYPE_FRM)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Allocate a thread */
retval = heap_getChunk(sizeof(PmThread_t), (uint8_t **)r_pobj);
PM_RETURN_IF_ERROR(retval);
/* Set type, frame and initialize status */
pthread = (pPmThread_t)*r_pobj;
OBJ_SET_TYPE(pthread, OBJ_TYPE_THR);
pthread->pframe = (pPmFrame_t)pframe;
pthread->interpctrl = INTERP_CTRL_CONT;
return retval;
}
PmReturn_t
dict_clear(pPmObj_t pdict)
{
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pdict != C_NULL);
/* Raise TypeError if arg is not a dict */
if (OBJ_GET_TYPE(pdict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* clear length */
((pPmDict_t)pdict)->length = 0;
/* Free the keys and values seglists if needed */
if (((pPmDict_t)pdict)->d_keys != C_NULL)
{
PM_RETURN_IF_ERROR(seglist_clear(((pPmDict_t)pdict)->d_keys));
PM_RETURN_IF_ERROR(heap_freeChunk((pPmObj_t)
((pPmDict_t)pdict)->d_keys));
((pPmDict_t)pdict)->d_keys = C_NULL;
}
if (((pPmDict_t)pdict)->d_vals != C_NULL)
{
PM_RETURN_IF_ERROR(seglist_clear(((pPmDict_t)pdict)->d_vals));
retval = heap_freeChunk((pPmObj_t)((pPmDict_t)pdict)->d_vals);
((pPmDict_t)pdict)->d_vals = C_NULL;
}
return retval;
}
// シェーダごとの初期化
BOOL CHemiLightShader::InitInternal(izanagi::graph::CGraphicsDevice* pDevice)
{
UNUSED_ALWAYS(pDevice);
IZ_ASSERT(m_pEffect != IZ_NULL);
if (!GetCommonParameterHandles()) {
return IZ_FALSE;
}
static const char* PARAM_NAME[] = {
"g_vEye",
"g_vMtrlDiffuse",
"g_vAxis",
"g_vUpColor",
"g_vDownColor",
};
C_ASSERT(COUNTOF(PARAM_NAME) == HANDLE_NUM);
IZ_BOOL result = GetParameterByName(
HANDLE_NUM,
m_hHandles,
PARAM_NAME);
IZ_ASSERT(result);
return result;
}
/**
* This functions handles an incoming ECSS packet.
* If the ECSS packet is part of a large data transfer consisting from
* several sequential ECSS packets, it handles them automatically.
*
* In other words, there is no need to explicitly check for a fragmented data
* transfer.
*
* @param payload the received payload
* @param payload_size the size of the payload
* @return SATR_OK if all went ok or appropriate error code
*/
SAT_returnState
rx_ecss (uint8_t *payload, const uint16_t payload_size)
{
SAT_returnState ret;
tc_tm_pkt *pkt;
pkt = get_pkt (payload_size);
if (!C_ASSERT(pkt != NULL)) {
return SATR_ERROR;
}
if (unpack_pkt (payload, pkt, payload_size) == SATR_OK) {
ret = route_pkt (pkt);
}
TC_TM_app_id dest = 0;
if(pkt->type == TC) {
dest = pkt->app_id;
}
else if(pkt->type == TM) {
dest = pkt->dest_id;
}
if(dest == SYSTEM_APP_ID) {
free_pkt(pkt);
}
return ret;
}
/* Warning: Can be called in interrupt context! */
PmReturn_t
pm_vmPeriodic(uint16_t usecsSinceLastCall)
{
/*
* Add the full milliseconds to pm_timerMsTicks and store additional
* microseconds for the next run. Thus, usecsSinceLastCall must be
* less than 2^16-1000 so it will not overflow usecResidual.
*/
static uint16_t usecResidual = 0;
C_ASSERT(usecsSinceLastCall < 64536);
usecResidual += usecsSinceLastCall;
while (usecResidual >= 1000)
{
usecResidual -= 1000;
pm_timerMsTicks++;
}
/* Check if enough time has passed for a scheduler run */
if ((pm_timerMsTicks - pm_lastRescheduleTimestamp)
>= PM_THREAD_TIMESLICE_MS)
{
interp_setRescheduleFlag((uint8_t)1);
pm_lastRescheduleTimestamp = pm_timerMsTicks;
}
return PM_RET_OK;
}
PmReturn_t
dict_delItem(pPmObj_t pdict, pPmObj_t pkey)
{
PmReturn_t retval = PM_RET_OK;
int16_t indx = 0;
C_ASSERT(pdict != C_NULL);
/* Check for matching key */
retval = seglist_findEqual(((pPmDict_t)pdict)->d_keys, pkey, &indx);
/* Raise KeyError if key is not found */
if (retval == PM_RET_NO)
{
PM_RAISE(retval, PM_RET_EX_KEY);
}
/* Return any other error */
PM_RETURN_IF_ERROR(retval);
/* Remove the key and value */
retval = seglist_removeItem(((pPmDict_t)pdict)->d_keys, indx);
PM_RETURN_IF_ERROR(retval);
retval = seglist_removeItem(((pPmDict_t)pdict)->d_vals, indx);
/* Reduce the item count */
((pPmDict_t)pdict)->length--;
return retval;
}
PmReturn_t
obj_repr(pPmObj_t pobj, pPmObj_t *r_pstr)
{
uint8_t tBuffer[32];
PmReturn_t retval = PM_RET_OK;
uint8_t const *pcstr = (uint8_t *)tBuffer;;
C_ASSERT(pobj != C_NULL);
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_INT:
retval = sli_ltoa10(((pPmInt_t)pobj)->val, tBuffer, sizeof(tBuffer));
PM_RETURN_IF_ERROR(retval);
retval = string_new(&pcstr, r_pstr);
break;
#ifdef HAVE_FLOAT
case OBJ_TYPE_FLT:
/* #212: Use homebrew float formatter */
retval = sli_ftoa(((pPmFloat_t)pobj)->val, tBuffer, sizeof(tBuffer));
sli_strlen((char *)tBuffer);
retval = string_new(&pcstr, r_pstr);
break;
#endif /* HAVE_FLOAT */
default:
/* Otherwise raise a TypeError */
PM_RAISE(retval, PM_RET_EX_TYPE);
break;
}
return retval;
}
BOOL
CNdasUnitDeviceCreator::IsConsistentDIB(
CONST NDAS_DIB_V2* pDIBv2)
{
XTLASSERT(!IsBadReadPtr(pDIBv2, sizeof(NDAS_DIB_V2)));
BOOL bConsistent = FALSE;
const NDAS_DEVICE_ID& deviceID = m_pDevice->GetDeviceId();
const DWORD unitNo = m_dwUnitNo;
for (DWORD i = 0; i < pDIBv2->nDiskCount + pDIBv2->nSpareCount && i < NDAS_MAX_UNITS_IN_V2; ++i)
{
C_ASSERT(
sizeof(deviceID.Node) ==
sizeof(pDIBv2->UnitDisks[i].MACAddr));
if (0 == memcmp(
deviceID.Node,
pDIBv2->UnitDisks[i].MACAddr,
sizeof(deviceID.Node)) &&
unitNo == pDIBv2->UnitDisks[i].UnitNumber)
{
bConsistent = TRUE;
}
}
return bConsistent;
}
/* Inserts in order a chunk into the free list. Caller adjusts heap state */
static PmReturn_t
heap_linkToFreelist(pPmHeapDesc_t pchunk)
{
uint16_t size;
pPmHeapDesc_t pscan;
/* Ensure the object is already free */
C_ASSERT(OBJ_GET_FREE(pchunk) != 0);
/* If free list is empty, add to head of list */
if (pmHeap.pfreelist == C_NULL)
{
pmHeap.pfreelist = pchunk;
pchunk->next = C_NULL;
pchunk->prev = C_NULL;
return PM_RET_OK;
}
/* Scan free list for insertion point */
pscan = pmHeap.pfreelist;
size = OBJ_GET_SIZE(pchunk);
while ((OBJ_GET_SIZE(pscan) < size) && (pscan->next != C_NULL))
{
pscan = pscan->next;
}
/*
* Insert chunk after the scan chunk (next is NULL).
* This is a slightly rare case where the last chunk in the free list
* is smaller than the chunk being freed.
*/
if (size > OBJ_GET_SIZE(pscan))
{
pchunk->next = pscan->next;
pscan->next = pchunk;
pchunk->prev = pscan;
}
/* Insert chunk before the scan chunk */
else
{
pchunk->next = pscan;
pchunk->prev = pscan->prev;
/* If chunk will be first item in free list */
if (pscan->prev == C_NULL)
{
pmHeap.pfreelist = pchunk;
}
else
{
pscan->prev->next = pchunk;
}
pscan->prev = pchunk;
}
return PM_RET_OK;
}
SAT_returnState HLDLC_deframe(uint8_t *buf_in,
uint8_t *buf_out,
const uint16_t size_in,
uint16_t *size_out) {
if(!C_ASSERT(buf_in != 0 && buf_out != 0) == true) { return SATR_ERROR; }
uint16_t cnt = 0;
// for(uint16_t i = 1; i < size_in; i++) {
// if(buf_in[i] == HLDLC_START_FLAG) {
// cnt = 0;
// }
for(uint16_t i = 0; i < size_in; i++) {
uint8_t c = buf_in[i];
if(c == HLDLC_START_FLAG) {
cnt = 0;
} else if(c == HLDLC_STOP_FLAG) {
*size_out = cnt;
return SATR_EOT;
} else if(c == HLDLC_CONTROL_FLAG) {
i++;
if(c == 0x5E) {
buf_out[cnt++] = 0x7E;
} else if(c == 0x5D) {
buf_out[cnt++] = 0x7D;
} else if(c== 0x5C) {
buf_out[cnt++] = 0x7C;
} else {
return SATR_ERROR;
}
} else {
buf_out[cnt++] = c;
}
if(!C_ASSERT(cnt < MAX_HLDLC_PKT_SIZE - 1) == true) {
return SATR_ERROR;
}
}
return SATR_ERROR;
}
SAT_returnState hk_crt_empty_pkt_TM(tc_tm_pkt **pkt, const TC_TM_app_id app_id, const HK_struct_id sid) {
*pkt = get_pkt(PKT_NORMAL);
if(!C_ASSERT(*pkt != NULL) == true) { return SATR_ERROR; }
hk_crt_pkt_TM(*pkt, app_id, sid);
return SATR_OK;
}
static t_block *cycle_fd(t_block **train, const int fd)
{
t_block *tmp;
tmp = *train;
while (tmp && tmp->fd != fd)
tmp = tmp->next;
if (!tmp)
{
C_ASSERT(tmp = (t_block *)ft_memalloc(sizeof(t_block)));
tmp->fd = fd;
C_ASSERT(tmp->str = ft_strnew(0));
tmp->next = *train;
*train = tmp;
}
return (tmp);
}
PmReturn_t
dict_update(pPmObj_t pdestdict, pPmObj_t psourcedict, uint8_t omit_underscored)
{
PmReturn_t retval = PM_RET_OK;
int16_t i;
pPmObj_t pkey;
pPmObj_t pval;
C_ASSERT(pdestdict != C_NULL);
C_ASSERT(psourcedict != C_NULL);
/* If it's not a dict, raise TypeError */
if (OBJ_GET_TYPE(pdestdict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* If it's not a dict, raise TypeError */
if (OBJ_GET_TYPE(psourcedict) != OBJ_TYPE_DIC)
{
PM_RAISE(retval, PM_RET_EX_TYPE);
return retval;
}
/* Iterate over the add-on dict */
for (i = 0; i < ((pPmDict_t)psourcedict)->length; i++)
{
/* Get the key,val from the add-on dict */
retval = seglist_getItem(((pPmDict_t)psourcedict)->d_keys, i, &pkey);
PM_RETURN_IF_ERROR(retval);
retval = seglist_getItem(((pPmDict_t)psourcedict)->d_vals, i, &pval);
PM_RETURN_IF_ERROR(retval);
if (!(omit_underscored && (OBJ_GET_TYPE(pkey) == OBJ_TYPE_STR)
&& ((pPmString_t)pkey)->val[0] == '_'))
{
/* Set the key,val to the destination dict */
retval = dict_setItem(pdestdict, pkey, pval);
PM_RETURN_IF_ERROR(retval);
}
}
return retval;
}
template < typename _T_REG_UNION > __forceinline void writeRegisterNoFence (
_T_REG_UNION RegUnion
) const throw ()
{
C_ASSERT(sizeof(UINT32) == sizeof(ULONG));
ULONG* const regPtr = reinterpret_cast<ULONG*>(
ULONG_PTR(this->basePtr) + ULONG(RegUnion.OFFSET));
::WRITE_REGISTER_NOFENCE_ULONG(regPtr, RegUnion.AsUint32);
} // writeRegisterNoFence<...> ( _T_REG_UNION )
PNDAS_LOGICALUNIT_DESCRIPTOR
WINAPI
NdasPortCtlBuildNdasAtaDeviceDescriptor(
__in NDAS_LOGICALUNIT_ADDRESS LogicalUnitAddress,
__in ULONG LogicalUnitFlags,
__in CONST NDAS_DEVICE_IDENTIFIER* DeviceIdentifier,
__in ULONG NdasDeviceFlagMask,
__in ULONG NdasDeviceFlags,
__in ACCESS_MASK AccessMode,
__in ULONG VirtualBytesPerBlock,
__in PLARGE_INTEGER VirtualLogicalBlockAddress)
{
DWORD requiredBytes = sizeof(NDAS_ATA_DEVICE_DESCRIPTOR);
PNDAS_ATA_DEVICE_DESCRIPTOR ndasAtaDeviceDescriptor =
static_cast<PNDAS_ATA_DEVICE_DESCRIPTOR>(
HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, requiredBytes));
if (NULL == ndasAtaDeviceDescriptor)
{
CTRACE(TRACE_LEVEL_ERROR, NDASPORTCTL_GENERAL,
"Memory allocation failure for %d bytes\n", requiredBytes);
SetLastError(ERROR_OUTOFMEMORY);
return NULL;
}
PNDAS_LOGICALUNIT_DESCRIPTOR logicalUnitDescriptor =
&ndasAtaDeviceDescriptor->Header;
logicalUnitDescriptor->Version = sizeof(NDAS_LOGICALUNIT_DESCRIPTOR);
logicalUnitDescriptor->Size = requiredBytes;
logicalUnitDescriptor->Address = LogicalUnitAddress;
logicalUnitDescriptor->Type = NdasAtaDevice;
logicalUnitDescriptor->Flags = LogicalUnitFlags;
ndasAtaDeviceDescriptor->NdasDeviceId = *DeviceIdentifier;
ndasAtaDeviceDescriptor->NdasDeviceFlagMask = NdasDeviceFlagMask;
ndasAtaDeviceDescriptor->NdasDeviceFlags = NdasDeviceFlags;
ndasAtaDeviceDescriptor->AccessMode = AccessMode;
const BYTE NDAS_DEVICE_PASSWORD_ANY[8] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
CopyMemory(
ndasAtaDeviceDescriptor->DevicePassword,
NDAS_DEVICE_PASSWORD_ANY,
sizeof(ndasAtaDeviceDescriptor->DevicePassword));
C_ASSERT(
sizeof(NDAS_DEVICE_PASSWORD_ANY) ==
sizeof(ndasAtaDeviceDescriptor->DevicePassword));
ndasAtaDeviceDescriptor->VirtualBytesPerBlock = VirtualBytesPerBlock;
ndasAtaDeviceDescriptor->VirtualLogicalBlockAddress = *VirtualLogicalBlockAddress;
return logicalUnitDescriptor;
}
/*Must use real pins*/
SAT_returnState power_control_api(FM_dev_id did, FM_fun_id fid, uint8_t *state) {
if(!C_ASSERT(did == SYS_DBG) == true) { return SATR_ERROR; }
if(!C_ASSERT(fid == P_OFF || fid == P_ON || fid == P_RESET || fid == SET_VAL) == true) { return SATR_ERROR; }
if(did == ADCS_SD_DEV_ID && fid == P_ON) { } //HAL_adcs_SD_ON(); }
else if(did == ADCS_SD_DEV_ID && fid == P_OFF) { }//HAL_adcs_SD_OFF(); }
else if(did == ADCS_SD_DEV_ID && fid == P_RESET) {
//HAL_adcs_SD_OFF();
HAL_sys_delay(60);
//HAL_adcs_SD_ON();
}
else if(did == SYS_DBG && fid == SET_VAL) {
//FIXME
}
return SATR_OK;
}
// Helper method for updating an interface dispatch indirection cell's stub and cache pointer atomically.
// Returns the value of the cache pointer that is not referenced by the cell after this operation. This can be
// NULL on the initial cell update, the value of the old cache pointer or the value of the new cache pointer
// supplied (in the case where another thread raced with us for the update and won). In any case, if the
// returned pointer is non-NULL it represents a cache that should be scheduled for release.
static InterfaceDispatchCache * UpdateCellStubAndCache(InterfaceDispatchCell * pCell,
void * pStub,
UIntNative newCacheValue)
{
C_ASSERT(offsetof(InterfaceDispatchCell, m_pStub) == 0);
C_ASSERT(offsetof(InterfaceDispatchCell, m_pCache) == sizeof(void*));
UIntNative oldCacheValue = (UIntNative)UpdatePointerPairAtomically(pCell, pStub, (void*)newCacheValue, false);
if (InterfaceDispatchCell::IsCache(oldCacheValue))
{
return (InterfaceDispatchCache *)oldCacheValue;
}
else
{
return nullptr;
}
}
template < typename _T_REG_UNION > __forceinline void readRegisterNoFence (
_Out_ _T_REG_UNION* RegUnionPtr
) const throw ()
{
C_ASSERT(sizeof(UINT32) == sizeof(ULONG));
ULONG* const regPtr = reinterpret_cast<ULONG*>(
ULONG_PTR(this->basePtr) + ULONG(RegUnionPtr->OFFSET));
RegUnionPtr->AsUint32 = ::READ_REGISTER_NOFENCE_ULONG(regPtr);
} // readRegisterNoFence<...> ( _T_REG_UNION* )
PmReturn_t
obj_loadFromImgObj(pPmObj_t pimg, pPmObj_t *r_pobj)
{
uint8_t const *imgaddr;
PmReturn_t retval;
C_ASSERT(OBJ_GET_TYPE(pimg) == OBJ_TYPE_CIO);
imgaddr = (uint8_t const *)&(((pPmCodeImgObj_t)pimg)->val);
retval = obj_loadFromImg(MEMSPACE_RAM, &imgaddr, r_pobj);
C_ASSERT(OBJ_GET_TYPE(*r_pobj) == OBJ_TYPE_COB);
/* All COs must reference the top of the code img obj
* so the image is marked and prevented from being reclaimed */
co_rSetCodeImgAddr((pPmCo_t)*r_pobj, (uint8_t const *)pimg);
return retval;
}
//used for DMA
SAT_returnState HLDLC_frame(uint8_t *buf_in, uint8_t *buf_out, uint16_t *size) {
if(!C_ASSERT(buf_in != NULL && buf_out != NULL && size != NULL) == true) { return SATR_ERROR; }
if(!C_ASSERT(*size <= MAX_PKT_SIZE) == true) { return SATR_ERROR; }
uint16_t cnt = 2;
for(uint16_t i = 0; i < *size; i++) {
if(i == 0) {
buf_out[0] = HLDLC_START_FLAG;
buf_out[1] = buf_in[0];
} else if(i == (*size) - 1) {
if(buf_in[i] == HLDLC_START_FLAG) {
buf_out[cnt++] = HLDLC_CONTROL_FLAG;
buf_out[cnt++] = 0x5E;
} else if(buf_in[i] == HLDLC_STOP_FLAG) {
buf_out[cnt++] = HLDLC_CONTROL_FLAG;
buf_out[cnt++] = 0x5C;
} else if(buf_in[i] == HLDLC_CONTROL_FLAG) {
buf_out[cnt++] = HLDLC_CONTROL_FLAG;
buf_out[cnt++] = 0x5D;
} else {
buf_out[cnt++] = buf_in[i];
}
buf_out[cnt++] = HLDLC_STOP_FLAG;
*size = cnt;
return SATR_EOT;
} else if(buf_in[i] == HLDLC_START_FLAG) {
buf_out[cnt++] = HLDLC_CONTROL_FLAG;
buf_out[cnt++] = 0x5E;
} else if(buf_in[i] == HLDLC_STOP_FLAG) {
buf_out[cnt++] = HLDLC_CONTROL_FLAG;
buf_out[cnt++] = 0x5C;
} else if(buf_in[i] == HLDLC_CONTROL_FLAG) {
buf_out[cnt++] = HLDLC_CONTROL_FLAG;
buf_out[cnt++] = 0x5D;
} else {
buf_out[cnt++] = buf_in[i];
}
}
return SATR_ERROR;
}
/*Must use real pins*/
SAT_returnState power_control_api(FM_dev_id did, FM_fun_id fid, uint8_t *state) {
if(!C_ASSERT(did == COMMS_WOD_PAT || did == SYS_DBG) == true) {
return SATR_ERROR;
}
if (!C_ASSERT(fid == P_OFF || fid == P_ON || fid == P_RESET
|| fid == SET_VAL) == true) {
return SATR_ERROR;
}
if (did == COMMS_WOD_PAT && fid == SET_VAL) {
comms_write_persistent_word(state[0],
__COMMS_HEADLESS_TX_FLASH_OFFSET);
}
else if(did == SYS_DBG && fid == SET_VAL) {
//FIXME
}
return SATR_OK;
}
SAT_returnState hk_crt_pkt_TC(tc_tm_pkt *pkt, const TC_TM_app_id app_id, const HK_struct_id sid) {
if(!C_ASSERT(app_id < LAST_APP_ID) == true) { return SATR_ERROR; }
crt_pkt(pkt, app_id, TC, TC_ACK_NO, TC_HOUSEKEEPING_SERVICE, TC_HK_REPORT_PARAMETERS, (TC_TM_app_id)SYSTEM_APP_ID);
pkt->data[0] = (char)sid;
pkt->len = 1;
return SATR_OK;
}
