static bool fifoInternalSend(u32 firstword, int extrawordcount, u32 * wordlist) {
if(extrawordcount>0 && !wordlist) return false;
if(fifo_freewords<extrawordcount+1) return false;
if(extrawordcount<0 || extrawordcount>(FIFO_MAX_DATA_BYTES/4)) return false;
int count = 0;
int oldIME = enterCriticalSection();
u32 head = fifo_waitBlock();
if(fifo_send_queue.head == FIFO_BUFFER_TERMINATE) {
fifo_send_queue.head = head;
} else {
FIFO_BUFFER_SETNEXT(fifo_send_queue.tail,head);
}
FIFO_BUFFER_DATA(head)=firstword;
fifo_send_queue.tail = head;
while (count<extrawordcount) {
u32 next = fifo_waitBlock();
if(fifo_send_queue.head == FIFO_BUFFER_TERMINATE) {
fifo_send_queue.head = next;
} else {
FIFO_BUFFER_SETNEXT(fifo_send_queue.tail,next);
}
FIFO_BUFFER_DATA(next)=wordlist[count];
count++;
fifo_send_queue.tail = next;
}
REG_IPC_FIFO_CR |= IPC_FIFO_SEND_IRQ;
leaveCriticalSection(oldIME);
return true;
}
//---------------------------------------------------------------------------------
void irqClearAUX(u32 mask) {
//---------------------------------------------------------------------------------
int oldIME = enterCriticalSection();
__irqClear(mask,irqTableAUX);
irqDisable( mask);
leaveCriticalSection(oldIME);
}
int fifoGetDatamsg(int channel, int buffersize, u8 * destbuffer) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return -1;
int block = fifo_data_queue[channel].head;
if (block == FIFO_BUFFER_TERMINATE) return -1;
int oldIME = enterCriticalSection();
int num_bytes = FIFO_BUFFER_GETEXTRA(block);
int num_words = (num_bytes+3)>>2;
u32 buffer_array[num_words];
int i,next;
for(i=0; i<num_words;i++) {
buffer_array[i] = FIFO_BUFFER_DATA(block);
next=FIFO_BUFFER_GETNEXT(block);
fifo_freeBlock(block);
block=next;
if(block==FIFO_BUFFER_TERMINATE) break;
}
fifo_data_queue[channel].head = block;
if(buffersize<num_bytes) num_bytes=buffersize;
memcpy(destbuffer,buffer_array,num_bytes);
leaveCriticalSection(oldIME);
return num_bytes;
}
//---------------------------------------------------------------------------------
void sdmmc_controller_init() {
//---------------------------------------------------------------------------------
int oldIME = enterCriticalSection();
// Reset
sdmmc_write16(0x100, 0x0402);
sdmmc_write16(0x100, 0x0000);
sdmmc_write16(0x104, 0x0000);
sdmmc_write16(0x108, 0x0001);
// InitIP
sdmmc_mask16(REG_SDRESET, 0x0001, 0x0000);
sdmmc_mask16(REG_SDRESET, 0x0000, 0x0001);
sdmmc_mask16(REG_SDSTOP, 0x0001, 0x0000);
// Reset
sdmmc_mask16(REG_SDOPT, 0x0005, 0x0000);
// EnableInfo
sdmmc_mask16(REG_SDSTATUS0, 0x0018, 0x0000);
sdmmc_mask16(0x20, 0x0018, 0x0000); // ??
sdmmc_mask16(0x20, 0x0000, 0x0018);
sdmmc_init_irq();
leaveCriticalSection(oldIME);
}
//------------------------------------------------------------------------------
tOplkError timeru_deleteTimer(tTimerHdl* pTimerHdl_p)
{
tTimerEntry* pTimerEntry;
tTimerEntry** ppEntry;
// check pointer to handle
if (pTimerHdl_p == NULL)
return kErrorTimerInvalidHandle;
// check handle itself, i.e. was the handle initialized before
if (*pTimerHdl_p == 0)
return kErrorOk;
pTimerEntry = (tTimerEntry*)*pTimerHdl_p;
// remove timer entry from timer list
enterCriticalSection(TIMERU_TIMER_LIST);
ppEntry = &timeruInstance_l.pTimerListFirst;
while (*ppEntry != NULL)
{
if (*ppEntry == pTimerEntry)
{
*ppEntry = pTimerEntry->pNext;
if (*ppEntry != NULL)
{
(*ppEntry)->timeoutInMs += pTimerEntry->timeoutInMs;
}
break;
}
ppEntry = &(*ppEntry)->pNext;
}
leaveCriticalSection(TIMERU_TIMER_LIST);
// insert in free list
enterCriticalSection(TIMERU_FREE_LIST);
pTimerEntry->pNext = timeruInstance_l.pFreeListFirst;
timeruInstance_l.pFreeListFirst = pTimerEntry;
timeruInstance_l.freeEntries++;
leaveCriticalSection(TIMERU_FREE_LIST);
// set handle invalid
*pTimerHdl_p = 0;
return kErrorOk;
}
//------------------------------------------------------------------------------
static DWORD WINAPI processThread(LPVOID parameter_p)
{
tTimerEntry* pTimerEntry;
UINT32 timeoutInMs;
UINT32 waitResult;
tOplkError ret;
UNUSED_PARAMETER(parameter_p);
for (;;)
{
ret = timeru_process();
if (ret != kErrorOk)
{
// Error
}
// calculate time until the next timer event
enterCriticalSection(TIMERU_TIMER_LIST);
pTimerEntry = timeruInstance_l.pTimerListFirst;
if (pTimerEntry == NULL)
{ // timer list is empty
timeoutInMs = INFINITE;
}
else
{
timeoutInMs = getTickCount() - timeruInstance_l.startTimeInMs;
if (timeoutInMs > pTimerEntry->timeoutInMs)
{ // timeout elapsed
timeoutInMs = 0;
}
else
{ // adjust timeout with elapsed time since start time
timeoutInMs = pTimerEntry->timeoutInMs - timeoutInMs;
}
}
leaveCriticalSection(TIMERU_TIMER_LIST);
waitResult = WaitForMultipleObjects(2, timeruInstance_l.ahEvents, FALSE, timeoutInMs);
switch (waitResult)
{
case (WAIT_OBJECT_0 + TIMERU_EVENT_SHUTDOWN):
goto Exit;
break;
case (WAIT_OBJECT_0 + TIMERU_EVENT_WAKEUP):
case WAIT_TIMEOUT:
break;
default:
// Error
break;
}
}
Exit:
return 0;
}
void * fifoGetAddress(int channel) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return NULL;
int block = fifo_address_queue[channel].head;
if (block == FIFO_BUFFER_TERMINATE) return NULL;
int oldIME = enterCriticalSection();
void *address = (void*)FIFO_BUFFER_DATA(block);
fifo_address_queue[channel].head = FIFO_BUFFER_GETNEXT(block);
fifo_freeBlock(block);
leaveCriticalSection(oldIME);
return address;
}
//---------------------------------------------------------------------------------
void irqSet(u32 mask, IntFn handler) {
//---------------------------------------------------------------------------------
int oldIME = enterCriticalSection();
__irqSet(mask,handler,irqTable);
if(mask & IRQ_VBLANK)
REG_DISPSTAT |= DISP_VBLANK_IRQ ;
if(mask & IRQ_HBLANK)
REG_DISPSTAT |= DISP_HBLANK_IRQ ;
if(mask & IRQ_IPC_SYNC)
REG_IPC_SYNC |= IPC_SYNC_IRQ_ENABLE;
leaveCriticalSection(oldIME);
}
u32 fifoGetValue32(int channel) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return 0;
int block = fifo_value32_queue[channel].head;
if ( block == FIFO_BUFFER_TERMINATE) return 0;
int oldIME = enterCriticalSection();
u32 value32 = FIFO_BUFFER_DATA(block);
fifo_value32_queue[channel].head = FIFO_BUFFER_GETNEXT(block);
fifo_freeBlock(block);
leaveCriticalSection(oldIME);
return value32;
}
/* Lookup or create a new TraceInfo */
static TraceInfo *
lookupOrEnter(jvmtiEnv *jvmti, Trace *trace, TraceFlavor flavor)
{
TraceInfo *tinfo;
jlong hashCode;
/* Calculate hash code (outside critical section to lessen contention) */
hashCode = hashTrace(trace);
/* Do a lookup in the hash table */
enterCriticalSection(jvmti);
{
TraceInfo *prev;
int hashIndex;
/* Start with first item in hash buck chain */
prev = NULL;
hashIndex = (int)(hashCode & HASH_INDEX_MASK);
tinfo = gdata->hashBuckets[hashIndex];
while ( tinfo != NULL ) {
if ( tinfo->hashCode == hashCode &&
memcmp(trace, &(tinfo->trace), sizeof(Trace))==0 ) {
/* We found one that matches, move to head of bucket chain */
if ( prev != NULL ) {
/* Remove from list and add to head of list */
prev->next = tinfo->next;
tinfo->next = gdata->hashBuckets[hashIndex];
gdata->hashBuckets[hashIndex] = tinfo;
}
/* Break out */
break;
}
prev = tinfo;
tinfo = tinfo->next;
}
/* If we didn't find anything we need to enter a new entry */
if ( tinfo == NULL ) {
/* Create new hash table element */
tinfo = newTraceInfo(trace, hashCode, flavor);
}
/* Update stats */
(void)updateStats(tinfo);
}
exitCriticalSection(jvmti);
return tinfo;
}
void CPythonEngine::threadGILAcquire(int ms)
{
init();
enterCriticalSection();
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
char buf[128];
sprintf(buf, "time.sleep(%d.%03d)", ms / 1000, ms % 1000);
PyRun_SimpleString(buf);
PyGILState_Release(gstate);
leaveCriticalSection();
}
//---------------------------------------------------------------------------------
void irqDisable(uint32 irq) {
//---------------------------------------------------------------------------------
int oldIME = enterCriticalSection();
if (irq & IRQ_VBLANK)
REG_DISPSTAT &= ~DISP_VBLANK_IRQ ;
if (irq & IRQ_HBLANK)
REG_DISPSTAT &= ~DISP_HBLANK_IRQ ;
if (irq & IRQ_VCOUNT)
REG_DISPSTAT &= ~DISP_YTRIGGER_IRQ;
if(irq & IRQ_IPC_SYNC)
REG_IPC_SYNC &= ~IPC_SYNC_IRQ_ENABLE;
REG_IE &= ~irq;
leaveCriticalSection(oldIME);
}
void CPythonEngine::backpipeTamsgTick()
{
init();
enterCriticalSection();
long int tm = GetTickCount();
CMemReader& reader = CMemReader::getMemReader();
CIpcMessage mess;
if (CIPCBackPipe::readFromPipe(&mess, 1007))
{
int msgLen;
char msgBuf[16384];
memset(msgBuf, 0, 16384);
memcpy(&msgLen, mess.payload, sizeof(int));
memcpy(msgBuf, mess.payload + 4, msgLen);
int scriptNr;
for (scriptNr = 0;; scriptNr++)
{
CPythonScript *pythonScript = CPythonScript::getScriptByNr(scriptNr);
if (!pythonScript)
break;
if (!pythonScript->isEnabled())
continue;
int funNr;
for (funNr = 0;; funNr++)
{
struct funType *fun = pythonScript->getFunDef(funNr);
if (!fun)
break;
if (fun->type == FUNTYPE_TAMSG)
{
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
PyObject *params = pythonScript->getParamsDic();
PyObject *result = PyObject_CallMethod(pythonScript->getPluginObject(), fun->name, "(Os)", params, msgBuf);
Py_XDECREF(params);
Py_XDECREF(result);
fun->call();
PyGILState_Release(gstate);
}
}
}
}
leaveCriticalSection();
}
int writeFirmwarePage(u32 address,u8 *buffer) {
int i;
u8 pagebuffer[256];
readFirmware(address, pagebuffer, 256);
if(memcmp(pagebuffer, buffer, 256) == 0) return 0;
int oldIME = enterCriticalSection();
//write enable
REG_SPICNT = SPI_ENABLE | SPI_CONTINUOUS | SPI_DEVICE_NVRAM;
readwriteSPI(FIRMWARE_WREN);
REG_SPICNT = 0;
//Wait for Write Enable Latch to be set
REG_SPICNT = SPI_ENABLE | SPI_CONTINUOUS | SPI_DEVICE_NVRAM;
readwriteSPI(FIRMWARE_RDSR);
while((readwriteSPI(0) & 0x02) == 0); //Write Enable Latch
REG_SPICNT = 0;
//page write
REG_SPICNT = SPI_ENABLE | SPI_CONTINUOUS | SPI_DEVICE_NVRAM;
readwriteSPI(FIRMWARE_PW);
// Set the address
readwriteSPI((address>>16) & 0xff);
readwriteSPI((address>> 8) & 0xff);
readwriteSPI((address) & 0xff);
for(i = 0; i < 256; i++) {
readwriteSPI(buffer[i]);
}
REG_SPICNT = 0;
// wait for programming to finish
REG_SPICNT = SPI_ENABLE|SPI_CONTINUOUS|SPI_DEVICE_NVRAM;
readwriteSPI(FIRMWARE_RDSR);
while(readwriteSPI(0) & 0x01); //Write In Progress
REG_SPICNT = 0;
leaveCriticalSection(oldIME);
// read it back & verify
readFirmware(address, pagebuffer, 256);
if(memcmp(pagebuffer, buffer, 256) == 0) return 0;
return -1;
}
//------------------------------------------------------------------------------
tOplkError timeru_process(void)
{
tTimerEntry* pTimerEntry;
UINT32 timeoutInMs;
tEvent event;
tTimerEventArg timerEventArg;
tOplkError ret = kErrorOk;
enterCriticalSection(TIMERU_TIMER_LIST);
// calculate elapsed time since start time
timeoutInMs = getTickCount() - timeruInstance_l.startTimeInMs;
// observe first timer entry in timer list
pTimerEntry = timeruInstance_l.pTimerListFirst;
if (pTimerEntry != NULL)
{
if (timeoutInMs >= pTimerEntry->timeoutInMs)
{ // timeout elapsed - remove entry from timer list
timeruInstance_l.pTimerListFirst = pTimerEntry->pNext;
// adjust start time
timeruInstance_l.startTimeInMs += pTimerEntry->timeoutInMs;
}
else
{
pTimerEntry = NULL;
}
}
leaveCriticalSection(TIMERU_TIMER_LIST);
if (pTimerEntry != NULL)
{
// call event function
timerEventArg.timerHdl = (tTimerHdl)pTimerEntry;
OPLK_MEMCPY(&timerEventArg.argument, &pTimerEntry->timerArg.argument, sizeof(timerEventArg.argument));
event.eventSink = pTimerEntry->timerArg.eventSink;
event.eventType = kEventTypeTimer;
OPLK_MEMSET(&event.netTime, 0x00, sizeof(tNetTime));
event.pEventArg = &timerEventArg;
event.eventArgSize = sizeof(timerEventArg);
ret = eventu_postEvent(&event);
}
return ret;
}
void CVmc::setMotorRPM(int motor, int rpm)
{
if((rpm < -1*_maxRpm) || (rpm > _maxRpm)) return;
if((motor < 1) || (motor > 3)) return;
enterCriticalSection();
switch(motor)
{
case 1: _pwmOut1= rpm; break;
case 2: _pwmOut2= rpm; break;
case 3: _pwmOut3= rpm; break;
default: break;
}
leaveCriticalSection();
}
/* Callback for JVMTI_EVENT_VM_START */
static void JNICALL
cbVMStart(jvmtiEnv *jvmti, JNIEnv *env)
{
enterCriticalSection(jvmti);
{
jclass klass;
jfieldID field;
jint rc;
/* Java Native Methods for class */
static JNINativeMethod registry[2] = {
{ STRING(HEAP_TRACKER_native_newobj), "(Ljava/lang/Object;Ljava/lang/Object;)V",
(void*)&HEAP_TRACKER_native_newobj
},
{ STRING(HEAP_TRACKER_native_newarr), "(Ljava/lang/Object;Ljava/lang/Object;)V",
(void*)&HEAP_TRACKER_native_newarr
}
};
/* Register Natives for class whose methods we use */
klass = (*env)->FindClass(env, STRING(HEAP_TRACKER_class));
if ( klass == NULL ) {
fatal_error("ERROR: JNI: Cannot find %s with FindClass\n",
STRING(HEAP_TRACKER_class));
}
rc = (*env)->RegisterNatives(env, klass, registry, 2);
if ( rc != 0 ) {
fatal_error("ERROR: JNI: Cannot register natives for class %s\n",
STRING(HEAP_TRACKER_class));
}
/* Engage calls. */
field = (*env)->GetStaticFieldID(env, klass, STRING(HEAP_TRACKER_engaged), "I");
if ( field == NULL ) {
fatal_error("ERROR: JNI: Cannot get field from %s\n",
STRING(HEAP_TRACKER_class));
}
(*env)->SetStaticIntField(env, klass, field, 1);
/* Indicate VM has started */
gdata->vmStarted = JNI_TRUE;
}
exitCriticalSection(jvmti);
}
// fifoSetAddressHandler - Set a callback to receive incoming address messages on a specific channel.
bool fifoSetAddressHandler(int channel, FifoAddressHandlerFunc newhandler, void * userdata) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return false;
int oldIME = enterCriticalSection();
fifo_address_func[channel] = newhandler;
fifo_address_data[channel] = userdata;
if(newhandler) {
while(fifoCheckAddress(channel)) {
newhandler( fifoGetAddress(channel), userdata );
}
}
leaveCriticalSection(oldIME);
return true;
}
/* Callback for JVMTI_EVENT_VM_INIT */
static void JNICALL
cbVMInit(jvmtiEnv *jvmti, JNIEnv *env, jthread thread)
{
jvmtiHeapCallbacks heapCallbacks;
jvmtiError error;
/* Iterate through heap, find all untagged objects allocated before this */
(void)memset(&heapCallbacks, 0, sizeof(heapCallbacks));
heapCallbacks.heap_iteration_callback = &cbObjectTagger;
error = (*jvmti)->IterateThroughHeap(jvmti, JVMTI_HEAP_FILTER_TAGGED,
NULL, &heapCallbacks, NULL);
check_jvmti_error(jvmti, error, "Cannot iterate through heap");
enterCriticalSection(jvmti); {
/* Indicate VM is initialized */
gdata->vmInitialized = JNI_TRUE;
} exitCriticalSection(jvmti);
}
bool MaekawaAlgorithm::receiveLocked(Packet locked){
printf("----Node %d has received LOCKED message from %d \n",processID,locked.ORIGIN);
// //Compare and maximize the sequence number
// if(sequenceNo < locked.SEQ)
// sequenceNo = locked.SEQ;
//Increase hasReceivedLockedMessage by 1. If this variable reaches K-1, then the node can enter the critical section.
//hasReceivedLockedMessage++;
//Update quorumVote table
int temp = -1;
for(int i = 0; i < quorumsize; i++){
if(quorumVote[i][0] == locked.ORIGIN) temp = i;
}
quorumVote[temp][1] = 1;
hasReceivedLockedMessage = 0;
printf("--^^--quorumVote Table--^^-- \n");
//Check if the current node has received all the locked messages
for(int i = 0; i < quorumsize; i++){
printf("%d , %d \n",quorumVote[i][0],quorumVote[i][1]);
if(quorumVote[i][1] == 1){
hasReceivedLockedMessage++;
}
}
printf("----Node %d has received %d LOCKED messages \n",processID,hasReceivedLockedMessage);
if(hasReceivedLockedMessage == quorumsize){
printf("----Node %d has entered critical section \n",processID);
enterCriticalSection();
//printf("Node %d has exited critical section \n",processID);
return true;
}
return true;
}
void CPythonEngine::periodicalTick()
{
init();
enterCriticalSection();
long int tm = GetTickCount();
int scriptNr;
for (scriptNr = 0;; scriptNr++)
{
CPythonScript *pythonScript = CPythonScript::getScriptByNr(scriptNr);
if (!pythonScript)
break;
if (!pythonScript->isEnabled())
continue;
int funNr;
for (funNr = 0;; funNr++)
{
struct funType *fun = pythonScript->getFunDef(funNr);
if (!fun)
break;
if (fun->type == FUNTYPE_PERIODICAL && tm >= fun->tmNextExec)
{
CPythonScript *pythonScript = CPythonScript::getScriptByNr(scriptNr);
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
PyObject *params = pythonScript->getParamsDic();
PyObject *result = PyObject_CallMethod(pythonScript->getPluginObject(), fun->name, "(O)", params);
Py_XDECREF(params);
Py_XDECREF(result);
fun->call();
PyGILState_Release(gstate);
}
}
}
leaveCriticalSection();
}
// fifoSetDatamsgHandler - Set a callback to receive incoming data sequences on a specific channel.
bool fifoSetDatamsgHandler(int channel, FifoDatamsgHandlerFunc newhandler, void * userdata) {
if(channel<0 || channel>=FIFO_NUM_CHANNELS) return false;
int oldIME = enterCriticalSection();
fifo_datamsg_func[channel] = newhandler;
fifo_datamsg_data[channel] = userdata;
if(newhandler) {
while(fifoCheckDatamsg(channel)) {
int block = fifo_data_queue[channel].head;
int n_bytes = FIFO_UNPACK_DATALENGTH(FIFO_BUFFER_DATA(block));
newhandler(n_bytes, userdata);
if (block == fifo_data_queue[channel].head) fifoGetDatamsg(channel,0,0);
}
}
leaveCriticalSection(oldIME);
return true;
}
void CPythonEngine::unloadScript(int scriptNr)
{
init();
enterCriticalSection();
CPythonScript *pythonScript = CPythonScript::getScriptByNr(scriptNr);
pythonScript->setEnabled(false);
struct funType *fun = NULL;
for (int funNr = 0; (fun = pythonScript->getFunDef(funNr)); funNr++)
{
if (fun->type == FUNTYPE_INPACKET)
CPackSender::unregisterInpacketRegex(fun->matchExprHandle);
}
CPythonScript::pythonScriptTab[scriptNr] = CPythonScript::pythonScriptTab[CPythonScript::pythonScriptCount - 1];
CPythonScript::pythonScriptCount--;
registerPluginCount--;
// this is commented out by purpose - there would be too much threads
// playing to cleanup this memory here
//delete pythonScript;//crashes TA on reloading script possibly fix later!
leaveCriticalSection();
}
// Calls python functions of type 3 when we receive notice of an incoming packet
void CPythonEngine::backpipeInpacketTick()
{
init();
enterCriticalSection();
CMemReader& reader = CMemReader::getMemReader();
CIpcMessage mess;
struct parcelRecvActionData* pd;
//runs at most 'maxtimes' python functions each tick
for (int maxtimes = 5; CIPCBackPipe::readFromPipe(&mess, 1010) && maxtimes > 0; maxtimes--)
{
char buf[1024];
long int tm = GetTickCount();
pd = (parcelRecvActionData*)&(mess.payload);
int discardIncompletePacket = pd->countLeft + 1 != pd->totalCount; //the initial packets were too old and were discarded
int countLeft = pd->countLeft;
int msgLen = pd->len;
int handle = pd->handle;
char* msgBuf = (char*)malloc(sizeof(pd->actionData) * (countLeft + 1));
memcpy(msgBuf, pd->actionData, pd->len);
while (countLeft && GetTickCount() - tm < 200) // wait for remaining sections to come in for up to 200ms(they should always be on their way)
{
if (CIPCBackPipe::readFromPipe(&mess, 1010))
{
if (pd->handle != handle || pd->countLeft != countLeft - 1)
sprintf(buf, "ERROR in backpipeInpacketTick: handle %d should be %d and count %d should be %d", pd->handle, handle, pd->countLeft, countLeft - 1);
//AfxMessageBox(buf);
memcpy(msgBuf + msgLen, pd->actionData, pd->len);
msgLen += pd->len;
countLeft = pd->countLeft;
}
}
if (countLeft)
{
sprintf(buf, "ERROR in backpipeInpacketTick: did not finish reading data");
//AfxMessageBox(buf);
}
else if (discardIncompletePacket)
{
int a = 0;// discard data and continue
}
else //everything is OK
{
sprintf(buf, "One packet took %dms", GetTickCount() - tm);
//if (GetTickCount() - tm>20) MessageBox(NULL, buf,"huaeotnre",0);
CPythonScript *pythonScript = NULL;
for (int scriptNr = 0; (pythonScript = CPythonScript::getScriptByNr(scriptNr)); scriptNr++)
{
if (!pythonScript->isEnabled())
continue;
struct funType *fun = NULL;
for (int funNr = 0; (fun = pythonScript->getFunDef(funNr)); funNr++)
{
if (fun->type == FUNTYPE_INPACKET && fun->matchExprHandle == pd->handle)
{
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
PyObject *result = PyObject_CallMethod(pythonScript->getPluginObject(), fun->name, "(s#)", msgBuf, msgLen);
Py_XDECREF(result);
fun->call();
PyGILState_Release(gstate);
goto inpacketTickCleanup;
}
}
}
}
inpacketTickCleanup:
msgBuf[0] = 0;
free(msgBuf);
}
leaveCriticalSection();
}
//---------------------------------------------------------------------------------
int sdmmc_sdcard_init() {
//---------------------------------------------------------------------------------
u16 sdaddr;
u32 resp0;
u32 resp1;
u32 resp2;
u32 resp3;
u32 resp4;
u32 resp5;
u32 resp6;
u32 resp7;
u32 ocr, ccs, hcs, response;
sdmmc_cardready = 0;
int oldIME = enterCriticalSection();
sdmmc_write16(REG_SDCLKCTL, 0x20);
sdmmc_write16(REG_SDOPT, 0x40EA); // XXX: document me!
sdmmc_write16(0x02, 0x400);
sdmmc_mask16(REG_SDCLKCTL, 0, 0x100);
sdmmc_write16(REG_SDCLKCTL, sdmmc_read16(REG_SDCLKCTL));
sdmmc_mask16(REG_SDCLKCTL, 0x100, 0);
sdmmc_mask16(REG_SDCLKCTL, 0, 0x200);
sdmmc_mask16(REG_SDCLKCTL, 0, 0x100);
// CMD0
sdmmc_send_command(0x0000, 0x0000, 0x0000);
sdmmc_send_command(0x0408, 0x01aa, 0x0000);
sdmmc_gotcmd8reply = 1;
if(sdmmc_timeout)
sdmmc_gotcmd8reply = 0;
if(sdmmc_gotcmd8reply)
hcs = (1<<30);
else
hcs = 0;
ocr = 0x00ff8000;
while (1) {
sdmmc_send_acmd41(ocr | hcs, &response);
if (response & 0x80000000)
break;
}
ccs = response & (1<<30);
if(ccs && hcs)
sdmmc_sdhc = 1;
else
sdmmc_sdhc = 0;
// CMD2 - get CID
sdmmc_send_command(2, 0, 0);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
resp2 = sdmmc_read16(REG_SDRESP2);
resp3 = sdmmc_read16(REG_SDRESP3);
resp4 = sdmmc_read16(REG_SDRESP4);
resp5 = sdmmc_read16(REG_SDRESP5);
resp6 = sdmmc_read16(REG_SDRESP6);
resp7 = sdmmc_read16(REG_SDRESP7);
sdmmc_cid[0] = resp0 | (u32)(resp1<<16);
sdmmc_cid[1] = resp2 | (u32)(resp3<<16);
sdmmc_cid[2] = resp4 | (u32)(resp5<<16);
sdmmc_cid[3] = resp6 | (u32)(resp7<<16);
// CMD3
sdmmc_send_command(3, 0, 0);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
sdaddr = resp1;
// CMD9 - get CSD
sdmmc_send_command(9, 0, sdaddr);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
resp2 = sdmmc_read16(REG_SDRESP2);
resp3 = sdmmc_read16(REG_SDRESP3);
resp4 = sdmmc_read16(REG_SDRESP4);
resp5 = sdmmc_read16(REG_SDRESP5);
resp6 = sdmmc_read16(REG_SDRESP6);
resp7 = sdmmc_read16(REG_SDRESP7);
sdmmc_write16(REG_SDCLKCTL, 0x100);
// CMD7
sdmmc_send_command(7, 0, sdaddr);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
// CMD55
sdmmc_send_command(55, 0, sdaddr);
// ACMD6
sdmmc_send_command(6, 2, 0);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
sdmmc_send_command(13, 0, sdaddr);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
sdmmc_send_command(16, 0x200, 0x0);
resp0 = sdmmc_read16(REG_SDRESP0);
resp1 = sdmmc_read16(REG_SDRESP1);
sdmmc_write16(REG_SDCLKCTL, sdmmc_read16(REG_SDCLKCTL));
sdmmc_write16(REG_SDBLKLEN, 0x200);
sdmmc_mask16(REG_SDCLKCTL, 0x100, 0);
sdmmc_cardready = 1;
leaveCriticalSection(oldIME);
return 0;
}
//---------------------------------------------------------------------------------
void irqEnableAUX(uint32 irq) {
//---------------------------------------------------------------------------------
int oldIME = enterCriticalSection();
REG_AUXIE |= irq;
leaveCriticalSection(oldIME);
}
/* Callback for JVMTI_EVENT_VM_DEATH */
static void JNICALL
cbVMDeath(jvmtiEnv *jvmti, JNIEnv *env)
{
jvmtiHeapCallbacks heapCallbacks;
jvmtiError error;
/* These are purposely done outside the critical section */
/* Force garbage collection now so we get our ObjectFree calls */
error = (*jvmti)->ForceGarbageCollection(jvmti);
check_jvmti_error(jvmti, error, "Cannot force garbage collection");
/* Iterate through heap and find all objects */
(void)memset(&heapCallbacks, 0, sizeof(heapCallbacks));
heapCallbacks.heap_iteration_callback = &cbObjectSpaceCounter;
error = (*jvmti)->IterateThroughHeap(jvmti, 0, NULL, &heapCallbacks, NULL);
check_jvmti_error(jvmti, error, "Cannot iterate through heap");
/* Process VM Death */
enterCriticalSection(jvmti); {
jclass klass;
jfieldID field;
jvmtiEventCallbacks callbacks;
/* Disengage calls in HEAP_TRACKER_class. */
klass = (*env)->FindClass(env, STRING(HEAP_TRACKER_class));
if ( klass == NULL ) {
fatal_error("ERROR: JNI: Cannot find %s with FindClass\n",
STRING(HEAP_TRACKER_class));
}
field = (*env)->GetStaticFieldID(env, klass, STRING(HEAP_TRACKER_engaged), "I");
if ( field == NULL ) {
fatal_error("ERROR: JNI: Cannot get field from %s\n",
STRING(HEAP_TRACKER_class));
}
(*env)->SetStaticIntField(env, klass, field, 0);
/* The critical section here is important to hold back the VM death
* until all other callbacks have completed.
*/
/* Clear out all callbacks. */
(void)memset(&callbacks,0, sizeof(callbacks));
error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks,
(jint)sizeof(callbacks));
check_jvmti_error(jvmti, error, "Cannot set jvmti callbacks");
/* Since this critical section could be holding up other threads
* in other event callbacks, we need to indicate that the VM is
* dead so that the other callbacks can short circuit their work.
* We don't expect an further events after VmDeath but we do need
* to be careful that existing threads might be in our own agent
* callback code.
*/
gdata->vmDead = JNI_TRUE;
/* Dump all objects */
if ( gdata->traceInfoCount > 0 ) {
TraceInfo **list;
int count;
int i;
stdout_message("Dumping heap trace information\n");
/* Create single array of pointers to TraceInfo's, sort, and
* print top gdata->maxDump top space users.
*/
list = (TraceInfo**)calloc(gdata->traceInfoCount,
sizeof(TraceInfo*));
if ( list == NULL ) {
fatal_error("ERROR: Ran out of malloc() space\n");
}
count = 0;
for ( i = 0 ; i < HASH_BUCKET_COUNT ; i++ ) {
TraceInfo *tinfo;
tinfo = gdata->hashBuckets[i];
while ( tinfo != NULL ) {
if ( count < gdata->traceInfoCount ) {
list[count++] = tinfo;
}
tinfo = tinfo->next;
}
}
if ( count != gdata->traceInfoCount ) {
fatal_error("ERROR: Count found by iterate doesn't match ours:"
" count=%d != traceInfoCount==%d\n",
count, gdata->traceInfoCount);
}
qsort(list, count, sizeof(TraceInfo*), &compareInfo);
for ( i = 0 ; i < count ; i++ ) {
if ( i >= gdata->maxDump ) {
break;
}
printTraceInfo(jvmti, i+1, list[i]);
}
(void)free(list);
}
} exitCriticalSection(jvmti);
}
//---------------------------------------------------------------------------------
void irqSetAUX(u32 mask, IntFn handler) {
//---------------------------------------------------------------------------------
int oldIME = enterCriticalSection();
__irqSet(mask,handler,irqTableAUX);
leaveCriticalSection(oldIME);
}
/* Callback for JVMTI_EVENT_CLASS_FILE_LOAD_HOOK */
static void JNICALL
cbClassFileLoadHook(jvmtiEnv *jvmti, JNIEnv* env,
jclass class_being_redefined, jobject loader,
const char* name, jobject protection_domain,
jint class_data_len, const unsigned char* class_data,
jint* new_class_data_len, unsigned char** new_class_data)
{
enterCriticalSection(jvmti); {
/* It's possible we get here right after VmDeath event, be careful */
if ( !gdata->vmDead ) {
const char * classname;
/* Name can be NULL, make sure we avoid SEGV's */
if ( name == NULL ) {
classname = java_crw_demo_classname(class_data, class_data_len,
NULL);
if ( classname == NULL ) {
fatal_error("ERROR: No classname in classfile\n");
}
} else {
classname = strdup(name);
if ( classname == NULL ) {
fatal_error("ERROR: Ran out of malloc() space\n");
}
}
*new_class_data_len = 0;
*new_class_data = NULL;
/* The tracker class itself? */
if ( strcmp(classname, STRING(HEAP_TRACKER_class)) != 0 ) {
jint cnum;
int systemClass;
unsigned char *newImage;
long newLength;
/* Get number for every class file image loaded */
cnum = gdata->ccount++;
/* Is it a system class? If the class load is before VmStart
* then we will consider it a system class that should
* be treated carefully. (See java_crw_demo)
*/
systemClass = 0;
if ( !gdata->vmStarted ) {
systemClass = 1;
}
newImage = NULL;
newLength = 0;
/* Call the class file reader/write demo code */
java_crw_demo(cnum,
classname,
class_data,
class_data_len,
systemClass,
STRING(HEAP_TRACKER_class),
"L" STRING(HEAP_TRACKER_class) ";",
NULL, NULL,
NULL, NULL,
STRING(HEAP_TRACKER_newobj), "(Ljava/lang/Object;)V",
STRING(HEAP_TRACKER_newarr), "(Ljava/lang/Object;)V",
&newImage,
&newLength,
NULL,
NULL);
/* If we got back a new class image, return it back as "the"
* new class image. This must be JVMTI Allocate space.
*/
if ( newLength > 0 ) {
unsigned char *jvmti_space;
jvmti_space = (unsigned char *)allocate(jvmti, (jint)newLength);
(void)memcpy((void*)jvmti_space, (void*)newImage, (int)newLength);
*new_class_data_len = (jint)newLength;
*new_class_data = jvmti_space; /* VM will deallocate */
}
/* Always free up the space we get from java_crw_demo() */
if ( newImage != NULL ) {
(void)free((void*)newImage); /* Free malloc() space with free() */
}
}
(void)free((void*)classname);
}
} exitCriticalSection(jvmti);
}
//------------------------------------------------------------------------------
tOplkError timeru_setTimer(tTimerHdl* pTimerHdl_p, ULONG timeInMs_p, tTimerArg argument_p)
{
tTimerEntry* pNewEntry;
tTimerEntry** ppEntry;
// check pointer to handle
if (pTimerHdl_p == NULL)
return kErrorTimerInvalidHandle;
// fetch entry from free timer list
enterCriticalSection(TIMERU_FREE_LIST);
pNewEntry = timeruInstance_l.pFreeListFirst;
if (pNewEntry != NULL)
{
timeruInstance_l.pFreeListFirst = pNewEntry->pNext;
timeruInstance_l.freeEntries--;
if (timeruInstance_l.minFreeEntries > timeruInstance_l.freeEntries)
{
timeruInstance_l.minFreeEntries = timeruInstance_l.freeEntries;
}
}
leaveCriticalSection(TIMERU_FREE_LIST);
if (pNewEntry == NULL)
{ // sorry, no free entry
return kErrorTimerNoTimerCreated;
}
*pTimerHdl_p = (tTimerHdl)pNewEntry;
OPLK_MEMCPY(&pNewEntry->timerArg, &argument_p, sizeof(tTimerArg));
// insert timer entry in timer list
enterCriticalSection(TIMERU_TIMER_LIST);
// calculate timeout based on start time
pNewEntry->timeoutInMs = (getTickCount() - timeruInstance_l.startTimeInMs) + timeInMs_p;
ppEntry = &timeruInstance_l.pTimerListFirst;
while (*ppEntry != NULL)
{
if ((*ppEntry)->timeoutInMs > pNewEntry->timeoutInMs)
{
(*ppEntry)->timeoutInMs -= pNewEntry->timeoutInMs;
break;
}
pNewEntry->timeoutInMs -= (*ppEntry)->timeoutInMs;
ppEntry = &(*ppEntry)->pNext;
}
// insert before **ppEntry
pNewEntry->pNext = *ppEntry;
*ppEntry = pNewEntry;
leaveCriticalSection(TIMERU_TIMER_LIST);
#if (TARGET_SYSTEM == _WIN32_ || TARGET_SYSTEM == _WINCE_ )
if (ppEntry == &timeruInstance_l.pTimerListFirst)
{
SetEvent(timeruInstance_l.ahEvents[TIMERU_EVENT_WAKEUP]);
}
#endif
return kErrorOk;
}
