void code2(int mode, LPSYMBOL s1, LPSYMBOL s2)
{
switch (mode) {
case AM_R8:
R8(s1->instr, s2->val8);
break;
case AM_R16:
R16(s1->instr, s2->val8);
break;
case AM_M8:
M8(s1->instr, s2->val8);
break;
case AM_M16:
M16(s1->instr, s2->val8);
break;
case AM_A8:
A8(s1->instr, s2->val16);
break;
case AM_A16:
A16(s1->instr, s2->val16);
break;
case AM_I16:
I16(s1->instr, s2->val16);
break;
case AM_I8:
I8(s1->instr, s2->val8);
break;
default:
break;
}
}
static void cvtSM88K(const unsigned char* src, int ns, unsigned char* dst)
{
TRACE("(%p, %d, %p)\n", src, ns, dst);
while (ns--) {
*dst++ = M8(src[0], src[1]);
src += 2;
}
}
static void cvtSM88C(DWORD srcRate, const unsigned char* src, LPDWORD nsrc,
DWORD dstRate, unsigned char* dst, LPDWORD ndst)
{
DWORD error = dstRate / 2;
TRACE("(%d, %p, %p, %d, %p, %p)\n", srcRate, src, nsrc, dstRate, dst, ndst);
while ((*ndst)--) {
*dst++ = M8(src[0], src[1]);
error = error + srcRate;
while (error > dstRate) {
src += 2;
(*nsrc)--;
if (*nsrc == 0)
return;
error = error - dstRate;
}
}
}
/**
* @brief Process standard request
*
* @param None
*
* @return None
*
* @details Parse standard request and perform the corresponding action.
*
*/
void USBD_StandardRequest(void)
{
/* clear global variables for new request */
g_usbd_CtrlInPointer = 0;
g_usbd_CtrlInSize = 0;
if(g_usbd_SetupPacket[0] & 0x80) /* request data transfer direction */
{
// Device to host
switch(g_usbd_SetupPacket[1])
{
case GET_CONFIGURATION:
{
// Return current configuration setting
/* Data stage */
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = g_usbd_UsbConfig;
USBD_SET_DATA1(EP1);
USBD_SET_PAYLOAD_LEN(EP1, 0);
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 1);
/* Status stage */
USBD_PrepareCtrlOut(0, 0);
DBG_PRINTF("Get configuration\n");
break;
}
case GET_DESCRIPTOR:
{
USBD_GetDescriptor();
break;
}
case GET_INTERFACE:
{
// Return current interface setting
/* Data stage */
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = g_usbd_UsbAltInterface;
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 1);
/* Status stage */
USBD_PrepareCtrlOut(0, 0);
DBG_PRINTF("Get interface\n");
break;
}
case GET_STATUS:
{
// Device
if(g_usbd_SetupPacket[0] == 0x80)
{
uint8_t u8Tmp;
u8Tmp = 0;
if(g_usbd_sInfo->gu8ConfigDesc[7] & 0x40) u8Tmp |= 1; // Self-Powered/Bus-Powered.
if(g_usbd_sInfo->gu8ConfigDesc[7] & 0x20) u8Tmp |= (g_usbd_RemoteWakeupEn << 1); // Remote wake up
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = u8Tmp;
}
// Interface
else if(g_usbd_SetupPacket[0] == 0x81)
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = 0;
// Endpoint
else if(g_usbd_SetupPacket[0] == 0x82)
{
uint8_t ep = g_usbd_SetupPacket[4] & 0xF;
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = USBD_GetStall(ep) ? 1 : 0;
}
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0) + 1) = 0;
/* Data stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 2);
/* Status stage */
USBD_PrepareCtrlOut(0, 0);
DBG_PRINTF("Get status\n");
break;
}
default:
{
/* Setup error, stall the device */
USBD_SET_EP_STALL(EP0);
USBD_SET_EP_STALL(EP1);
DBG_PRINTF("Unknown request. stall ctrl pipe.\n");
break;
}
}
}
else
{
// Host to device
switch(g_usbd_SetupPacket[1])
{
case CLEAR_FEATURE:
{
if(g_usbd_SetupPacket[2] == FEATURE_ENDPOINT_HALT)
{
int32_t epNum, i;
/* EP number stall is not allow to be clear in MSC class "Error Recovery Test".
a flag: g_u32EpStallLock is added to support it */
epNum = g_usbd_SetupPacket[4] & 0xF;
for(i = 0; i < USBD_MAX_EP; i++)
{
if(((USBD->EP[i].CFG & 0xF) == epNum) && ((g_u32EpStallLock & (1 << i)) == 0))
{
USBD->EP[i].CFGP &= ~USBD_CFGP_SSTALL_Msk;
DBG_PRINTF("Clr stall ep%d %x\n",i, USBD->EP[i].CFGP);
}
}
}
else if(g_usbd_SetupPacket[2] == FEATURE_DEVICE_REMOTE_WAKEUP)
g_usbd_RemoteWakeupEn = 0;
/* Status stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 0);
DBG_PRINTF("Clear feature op %d\n", g_usbd_SetupPacket[2]);
break;
}
case SET_ADDRESS:
{
g_usbd_UsbAddr = g_usbd_SetupPacket[2];
DBG_PRINTF("Set addr to %d\n", g_usbd_UsbAddr);
// DATA IN for end of setup
/* Status Stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 0);
break;
}
case SET_CONFIGURATION:
{
g_usbd_UsbConfig = g_usbd_SetupPacket[2];
if(g_usbd_pfnSetConfigCallback)
g_usbd_pfnSetConfigCallback();
// DATA IN for end of setup
/* Status stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 0);
DBG_PRINTF("Set config to %d\n", g_usbd_UsbConfig);
break;
}
case SET_FEATURE:
{
if(g_usbd_SetupPacket[2] == FEATURE_ENDPOINT_HALT)
{
USBD_SetStall(g_usbd_SetupPacket[4] & 0xF);
DBG_PRINTF("Set feature. stall ep %d\n", g_usbd_SetupPacket[4] & 0xF);
}
else if(g_usbd_SetupPacket[2] == FEATURE_DEVICE_REMOTE_WAKEUP)
{
g_usbd_RemoteWakeupEn = 1;
DBG_PRINTF("Set feature. enable remote wakeup\n");
}
/* Status stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 0);
break;
}
case SET_INTERFACE:
{
g_usbd_UsbAltInterface = g_usbd_SetupPacket[2];
if(g_usbd_pfnSetInterface != NULL)
g_usbd_pfnSetInterface();
/* Status stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 0);
DBG_PRINTF("Set interface to %d\n", g_usbd_UsbAltInterface);
break;
}
default:
{
/* Setup error, stall the device */
USBD_SET_EP_STALL(EP0);
USBD_SET_EP_STALL(EP1);
DBG_PRINTF("Unsupported request. stall ctrl pipe.\n");
break;
}
}
}
}
void FastMatmulRecursive(LockAndCounter& locker, MemoryManager<Scalar>& mem_mngr, Matrix<Scalar>& A, Matrix<Scalar>& B, Matrix<Scalar>& C, int total_steps, int steps_left, int start_index, double x, int num_threads, Scalar beta) {
// Update multipliers
C.UpdateMultiplier(A.multiplier());
C.UpdateMultiplier(B.multiplier());
A.set_multiplier(Scalar(1.0));
B.set_multiplier(Scalar(1.0));
// Base case for recursion
if (steps_left == 0) {
MatMul(A, B, C);
return;
}
Matrix<Scalar> A11 = A.Subblock(2, 2, 1, 1);
Matrix<Scalar> A12 = A.Subblock(2, 2, 1, 2);
Matrix<Scalar> A21 = A.Subblock(2, 2, 2, 1);
Matrix<Scalar> A22 = A.Subblock(2, 2, 2, 2);
Matrix<Scalar> B11 = B.Subblock(2, 2, 1, 1);
Matrix<Scalar> B12 = B.Subblock(2, 2, 1, 2);
Matrix<Scalar> B21 = B.Subblock(2, 2, 2, 1);
Matrix<Scalar> B22 = B.Subblock(2, 2, 2, 2);
Matrix<Scalar> C11 = C.Subblock(2, 2, 1, 1);
Matrix<Scalar> C12 = C.Subblock(2, 2, 1, 2);
Matrix<Scalar> C21 = C.Subblock(2, 2, 2, 1);
Matrix<Scalar> C22 = C.Subblock(2, 2, 2, 2);
// Matrices to store the results of multiplications.
#ifdef _PARALLEL_
Matrix<Scalar> M1(mem_mngr.GetMem(start_index, 1, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M2(mem_mngr.GetMem(start_index, 2, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M3(mem_mngr.GetMem(start_index, 3, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M4(mem_mngr.GetMem(start_index, 4, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M5(mem_mngr.GetMem(start_index, 5, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M6(mem_mngr.GetMem(start_index, 6, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M7(mem_mngr.GetMem(start_index, 7, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M8(mem_mngr.GetMem(start_index, 8, total_steps - steps_left, M), C11.m(), C11.m(), C11.n(), C.multiplier());
#else
Matrix<Scalar> M1(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M2(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M3(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M4(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M5(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M6(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M7(C11.m(), C11.n(), C.multiplier());
Matrix<Scalar> M8(C11.m(), C11.n(), C.multiplier());
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
bool sequential1 = should_launch_task(8, total_steps, steps_left, start_index, 1, num_threads);
bool sequential2 = should_launch_task(8, total_steps, steps_left, start_index, 2, num_threads);
bool sequential3 = should_launch_task(8, total_steps, steps_left, start_index, 3, num_threads);
bool sequential4 = should_launch_task(8, total_steps, steps_left, start_index, 4, num_threads);
bool sequential5 = should_launch_task(8, total_steps, steps_left, start_index, 5, num_threads);
bool sequential6 = should_launch_task(8, total_steps, steps_left, start_index, 6, num_threads);
bool sequential7 = should_launch_task(8, total_steps, steps_left, start_index, 7, num_threads);
bool sequential8 = should_launch_task(8, total_steps, steps_left, start_index, 8, num_threads);
#else
bool sequential1 = false;
bool sequential2 = false;
bool sequential3 = false;
bool sequential4 = false;
bool sequential5 = false;
bool sequential6 = false;
bool sequential7 = false;
bool sequential8 = false;
#endif
// M1 = (1 * A11) * (1 * B11)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential1) shared(mem_mngr, locker) untied
{
#endif
M1.UpdateMultiplier(Scalar(1));
M1.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A11, B11, M1, total_steps, steps_left - 1, (start_index + 1 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 1, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M2 = (1 * A12) * (1 * B21)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential2) shared(mem_mngr, locker) untied
{
#endif
M2.UpdateMultiplier(Scalar(1));
M2.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A12, B21, M2, total_steps, steps_left - 1, (start_index + 2 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 2, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M3 = (1 * A11) * (1 * B12)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential3) shared(mem_mngr, locker) untied
{
#endif
M3.UpdateMultiplier(Scalar(1));
M3.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A11, B12, M3, total_steps, steps_left - 1, (start_index + 3 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 3, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M4 = (1 * A12) * (1 * B22)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential4) shared(mem_mngr, locker) untied
{
#endif
M4.UpdateMultiplier(Scalar(1));
M4.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A12, B22, M4, total_steps, steps_left - 1, (start_index + 4 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 4, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M5 = (1 * A21) * (1 * B11)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential5) shared(mem_mngr, locker) untied
{
#endif
M5.UpdateMultiplier(Scalar(1));
M5.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A21, B11, M5, total_steps, steps_left - 1, (start_index + 5 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 5, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M6 = (1 * A22) * (1 * B21)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential6) shared(mem_mngr, locker) untied
{
#endif
M6.UpdateMultiplier(Scalar(1));
M6.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A22, B21, M6, total_steps, steps_left - 1, (start_index + 6 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 6, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M7 = (1 * A21) * (1 * B12)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential7) shared(mem_mngr, locker) untied
{
#endif
M7.UpdateMultiplier(Scalar(1));
M7.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A21, B12, M7, total_steps, steps_left - 1, (start_index + 7 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 7, num_threads)) {
# pragma omp taskwait
# if defined(_PARALLEL_) && (_PARALLEL_ == _HYBRID_PAR_)
SwitchToDFS(locker, num_threads);
# endif
}
#endif
// M8 = (1 * A22) * (1 * B22)
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
# pragma omp task if(sequential8) shared(mem_mngr, locker) untied
{
#endif
M8.UpdateMultiplier(Scalar(1));
M8.UpdateMultiplier(Scalar(1));
FastMatmulRecursive(locker, mem_mngr, A22, B22, M8, total_steps, steps_left - 1, (start_index + 8 - 1) * 8, x, num_threads, Scalar(0.0));
#ifndef _PARALLEL_
#endif
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
locker.Decrement();
}
if (should_task_wait(8, total_steps, steps_left, start_index, 8, num_threads)) {
# pragma omp taskwait
}
#endif
M_Add1(M1, M2, C11, x, false, beta);
M_Add2(M3, M4, C12, x, false, beta);
M_Add3(M5, M6, C21, x, false, beta);
M_Add4(M7, M8, C22, x, false, beta);
// Handle edge cases with dynamic peeling
#if defined(_PARALLEL_) && (_PARALLEL_ == _BFS_PAR_ || _PARALLEL_ == _HYBRID_PAR_)
if (total_steps == steps_left) {
mkl_set_num_threads_local(num_threads);
mkl_set_dynamic(0);
}
#endif
DynamicPeeling(A, B, C, 2, 2, 2, beta);
}
void MSC_ClassRequest(void)
{
uint8_t buf[8];
USBD_GetSetupPacket(buf);
if (buf[0] & 0x80) /* request data transfer direction */
{
// Device to host
switch (buf[1])
{
case GET_MAX_LUN:
{
/* Check interface number with cfg descriptor and check wValue = 0, wLength = 1 */
if ((((buf[3]<<8)+buf[2]) == 0) && (((buf[5]<<8)+buf[4]) == 0) && (((buf[7]<<8)+buf[6]) == 1))
{
M8(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP0)) = 0;
/* Data stage */
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 1);
/* Status stage */
USBD_PrepareCtrlOut(0,0);
}
else /* Invalid Get MaxLun command */
{
USBD_SetStall(0);
}
break;
}
default:
{
/* Setup error, stall the device */
USBD_SetStall(0);
break;
}
}
}
else
{
// Host to device
switch (buf[1])
{
case BULK_ONLY_MASS_STORAGE_RESET:
{
/* Check interface number with cfg descriptor and check wValue = 0, wLength = 0 */
if ((((buf[3]<<8)+buf[2]) == 0) && (((buf[5]<<8)+buf[4]) == 0) && (((buf[7]<<8)+buf[6]) == 0))
{
USBD_SET_DATA1(EP0);
USBD_SET_PAYLOAD_LEN(EP0, 0);
USBD_LockEpStall(0);
/* Clear ready */
USBD->EP[EP2].CFG |= USBD_CFG_CLRRDY_Msk;
USBD->EP[EP3].CFG |= USBD_CFG_CLRRDY_Msk;
/* Prepare to receive the CBW */
g_u8EP3Ready = 0;
g_u8BulkState = BULK_CBW;
USBD_SET_DATA1(EP3);
USBD_SET_EP_BUF_ADDR(EP3, g_u32BulkBuf0);
USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
}
else /* Invalid Reset command */
{
USBD_SetStall(0);
}
break;
}
default:
{
// Stall
/* Setup error, stall the device */
USBD_SetStall(0);
break;
}
}
}
}