rik/jlibusb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- BDI_dll.cpp updated (wrong version was checked in)

Browse Source 
git-svn-id: https://svn.code.sf.net/p/libusbjava/code/trunk@80 94ad28fe-ef68-46b1-9651-e7ae4fcf1c4c
This commit is contained in:
schlaepfer
2006-01-10 17:00:38 +00:00
parent 7ee1c619da
commit c9a57cfdfa
3 changed files with 212 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
JNIdll/BDI.dll Normal file
View File

Binary file not shown.

319
JNIdll/BDI_dll.cpp
View File

@@ -1,13 +1,15 @@
#include <jni.h> #include <jni.h>
#include <windows.h> #include <windows.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdarg.h>
#define EXPORT JNIEXPORT #define EXPORT JNIEXPORT
//#define STACKTRACE_DEPTH 5 #define NOF_VM_ARGS 4
#define NOF_VM_ARGS 5
//#define PIPEBUFSIZE 4096 #define PIPEBUFSIZE 4096
//#define PIPE_TIMEOUT 500 //ms #define PIPE_TIMEOUT 500 //ms
// Classes // Classes
#define USB_Device_Class "ch/ntb/mcdp/usb/USBDevice" #define USB_Device_Class "ch/ntb/mcdp/usb/USBDevice"
#define BDI555_Class "ch/ntb/mcdp/bdi/MPC555" #define BDI555_Class "ch/ntb/mcdp/bdi/MPC555"
@@ -19,9 +21,17 @@
JNIEnv *env = NULL; JNIEnv *env = NULL;
JavaVM *jvm = NULL; JavaVM *jvm = NULL;
// Pipe names
char stdout_pipename[32] = "\\\\.\\pipe\\BDIDll_stdout";
char stderr_pipename[32] = "\\\\.\\pipe\\BDIDll_stderr";
// Pipe handles // Pipe handles
HANDLE hStdout_pipe, hStderr_pipe; HANDLE hStdout_pipe, hStderr_pipe;
// status flags
int stdOutErr_redirected = FALSE;
int jvm_created = FALSE, jvm_classPtrs_done = FALSE, \
jvm_mIDs_done = FALSE, jvm_redirection_done = FALSE;
// Java classes // Java classes
jclass cls_USB_Device, cls_BDI555, cls_BDI332, cls_Redirect, cls_Uart0; jclass cls_USB_Device, cls_BDI555, cls_BDI332, cls_Redirect, cls_Uart0;
// USB_Device // USB_Device
@@ -46,6 +56,70 @@ jmethodID mid_Redirect_redirect;
// Uart0 // Uart0
jmethodID mid_Uart0_write, mid_Uart0_read; jmethodID mid_Uart0_write, mid_Uart0_read;
BOOL setupNamedPipes(){
hStdout_pipe = CreateNamedPipe(
stdout_pipename, // pipe name
PIPE_ACCESS_INBOUND,// server only writes and client only reads
PIPE_TYPE_BYTE | // message type pipe
PIPE_WAIT, // non blocking mode
1, // max. instances
PIPEBUFSIZE, // output buffer size
PIPEBUFSIZE, // input buffer size
PIPE_TIMEOUT, // client time-out
NULL); // default security attribute
if (hStdout_pipe == INVALID_HANDLE_VALUE)
{
fprintf(stderr, "CreateNamedPipe (stdout_pipe) failed\n");
return FALSE;
}
hStderr_pipe = CreateNamedPipe(
stderr_pipename, // pipe name
PIPE_ACCESS_INBOUND,// server only writes and client only reads
PIPE_TYPE_BYTE | // message type pipe
PIPE_WAIT, // non blocking mode
1, // max. instances
PIPEBUFSIZE, // output buffer size
PIPEBUFSIZE, // input buffer size
PIPE_TIMEOUT, // client time-out
NULL); // default security attribute
if (hStderr_pipe == INVALID_HANDLE_VALUE)
{
fprintf(stderr, "CreateNamedPipe (stderr_pipe) failed\n");
return FALSE;
}
// Connect the reading end of the hStdout_pipe and assign it to stdout
if (freopen(stdout_pipename, "w", stdout) == NULL) {
fprintf(stderr, "freopen(stdout_pipename, w, stdout) failed\n");
return FALSE;
}
// Connect the reading end of the hStderr_pipe and assign it to sterr
if (freopen(stderr_pipename, "w", stderr) == NULL) {
fprintf(stderr, "freopen(stderr_pipename, w, stderr) failed\n");
return FALSE;
}
return TRUE;
}
void flushAll()
{
fflush(stderr);
fflush(stdout);
}
void fprintf_flush(FILE* stream, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
vfprintf(stream, format, argptr);
fflush(stream);
}
EXPORT HANDLE getOutPipeHandle(){ EXPORT HANDLE getOutPipeHandle(){
return hStdout_pipe; return hStdout_pipe;
} }
@@ -54,23 +128,6 @@ EXPORT HANDLE getErrPipeHandle(){
return hStderr_pipe; return hStderr_pipe;
} }
//BOOL redirect(){
//
// // Connect the reading end of the hStdout_pipe and assign it to stdout
// if (freopen(stdout_pipename, "w", stdout) == NULL) {
// fprintf(stderr, "freopen(stdout_pipename, w, stdout) failed\n");
// return FALSE;
// }
//
// // Connect the reading end of the hStderr_pipe and assign it to sterr
// if (freopen(stderr_pipename, "w", stderr) == NULL) {
// fprintf(stderr, "freopen(stderr_pipename, w, stderr) failed\n");
// return FALSE;
// }
// return TRUE;
//}
EXPORT int destroyJVM() EXPORT int destroyJVM()
{ {
jint result = -1; jint result = -1;
@@ -78,18 +135,18 @@ EXPORT int destroyJVM()
if (env->ExceptionOccurred()) { if (env->ExceptionOccurred()) {
env->ExceptionDescribe(); env->ExceptionDescribe();
} }
env = NULL;
} }
if (jvm) { if (jvm) {
result = jvm->DestroyJavaVM(); result = jvm->DestroyJavaVM();
jvm = NULL; fprintf_flush(stderr, "JVM destroyed\n");
fprintf(stderr, "JVM destroyed\n");
} }
// if (!CloseHandle(hStdout_pipe)) // reset flags
// fprintf(stderr, "Close stdout_pipe failed\n"); jvm_created = FALSE;
// if (!CloseHandle(hStderr_pipe)) jvm_classPtrs_done = FALSE;
// fprintf(stderr, "Close stderr_pipe failed\n"); jvm_mIDs_done = FALSE;
return result; jvm_redirection_done = FALSE;
return result;
} }
jint JNICALL _vfprintf_(FILE *fp, const char *format, va_list args) jint JNICALL _vfprintf_(FILE *fp, const char *format, va_list args)
@@ -100,340 +157,346 @@ jint JNICALL _vfprintf_(FILE *fp, const char *format, va_list args)
EXPORT int createJVM(char *classpath) EXPORT int createJVM(char *classpath)
{ {
char javaclasspath[1024];
char javaclasspath[128];
jint res; jint res;
JavaVMInitArgs vm_args; JavaVMInitArgs vm_args;
JavaVMOption options[NOF_VM_ARGS]; JavaVMOption options[NOF_VM_ARGS];
if (jvm == NULL) { if (!stdOutErr_redirected) {
// writing to the stdout/stderr stream will write to pipes
// USE fprintf_flush INSTEAD OF printf/fprintf TO WRITE TO THE PIPES
if (!setupNamedPipes()) {
fprintf_flush(stderr, "setupNamedPipes() failed\n");
return FALSE;
}
stdOutErr_redirected = TRUE;
}
// if (!setupNamedPipes()) { if (!jvm_created) {
// printf("setupNamedPipes() failed\n");
// return FALSE; fprintf_flush(stdout, "Starting JVM: classpath: %s\n", classpath);
// }
sprintf(javaclasspath, "-Djava.class.path=%s", classpath); sprintf(javaclasspath, "-Djava.class.path=%s", classpath);
// TODO: remove options[0].optionString = "-Xmx20m"; // specify the maximum heap size that the JVM is allowed to grow to
printf("classpath: %s\n", javaclasspath); options[1].optionString = javaclasspath;
options[2].optionString = "-verbose:class,jni";
options[0].optionString = javaclasspath; options[3].optionString = "-Djava.compiler=NONE";
options[1].optionString = "-Xms4M";
options[2].optionString = "-Xmx64M";
options[3].optionString = "-Xss512K";
options[4].optionString = "-Xoss400K";
// options[1].optionString = "-Xoss";
// options[2].optionString = "-Xmx512m";
// options[3].optionString = "-Xss5m";
// options[1].optionString = "-XX:+StackTraceInThrowable";
// options[2].optionString = "-Xcheck:jni";
//
// options[3].optionString = "vfprintf";
// options[3].extraInfo = (void*) _vfprintf_;
// sprintf(options[2].optionString, "-XX:MaxJavaStackTraceDepth=%d", STACKTRACE_DEPTH);
vm_args.version = JNI_VERSION_1_4; vm_args.version = JNI_VERSION_1_4;
vm_args.options = options; vm_args.options = options;
vm_args.nOptions = NOF_VM_ARGS; vm_args.nOptions = NOF_VM_ARGS;
vm_args.ignoreUnrecognized = JNI_FALSE; vm_args.ignoreUnrecognized = JNI_FALSE;
// TODO: remove
printf("trying to create jvm\n");
/* Create the Java VM */ /* Create the Java VM */
res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
if (res < 0) { if (res < 0) {
fprintf(stderr, "Can't create Java VM\n"); fprintf_flush(stderr, "Can't create Java VM\n");
return FALSE; return FALSE;
} }
jvm_created = TRUE;
} else {
fprintf_flush(stdout, "JVM already created -> creating class pointers\n");
}
// TODO: remove if (!jvm_classPtrs_done) {
printf("jvm created\n");
/* create class pointers */ /* create class pointers */
cls_USB_Device = env->FindClass(USB_Device_Class); cls_USB_Device = env->FindClass(USB_Device_Class);
if (cls_USB_Device == 0) { if (cls_USB_Device == 0) {
fprintf(stderr, "Can't find %s class", USB_Device_Class); fprintf_flush(stderr, "Can't find %s class\n", USB_Device_Class);
return FALSE; return FALSE;
} }
cls_BDI555 = env->FindClass(BDI555_Class); cls_BDI555 = env->FindClass(BDI555_Class);
if (cls_BDI555 == 0) { if (cls_BDI555 == 0) {
fprintf(stderr, "Can't find %s class", BDI555_Class); fprintf_flush(stderr, "Can't find %s class\n", BDI555_Class);
return FALSE; return FALSE;
} }
cls_BDI332 = env->FindClass(BDI332_Class); cls_BDI332 = env->FindClass(BDI332_Class);
if (cls_BDI332 == 0) { if (cls_BDI332 == 0) {
fprintf(stderr, "Can't find %s class", BDI332_Class); fprintf_flush(stderr, "Can't find %s class\n", BDI332_Class);
return FALSE; return FALSE;
} }
cls_Redirect = env->FindClass(Redirect_Class); cls_Redirect = env->FindClass(Redirect_Class);
if (cls_Redirect == 0) { if (cls_Redirect == 0) {
fprintf(stderr, "Can't find %s class", Redirect_Class); fprintf_flush(stderr, "Can't find %s class\n", Redirect_Class);
return FALSE; return FALSE;
} }
cls_Uart0 = env->FindClass(Uart0_Class); cls_Uart0 = env->FindClass(Uart0_Class);
if (cls_Uart0 == 0) { if (cls_Uart0 == 0) {
fprintf(stderr, "Can't find %s class", Uart0_Class); fprintf_flush(stderr, "Can't find %s class\n", Uart0_Class);
return FALSE; return FALSE;
} }
jvm_classPtrs_done = TRUE;
} else {
fprintf_flush(stdout, "Class Pointers already created -> creating method IDs\n");
}
if (!jvm_mIDs_done) {
/* create method pointers */ /* create method pointers */
// USB_Device // USB_Device
mid_USB_Dev_open = env->GetStaticMethodID(cls_USB_Device, "open", "()V"); mid_USB_Dev_open = env->GetStaticMethodID(cls_USB_Device, "open", "()V");
if (mid_USB_Dev_open == 0) { if (mid_USB_Dev_open == 0) {
fprintf(stderr, "Can't find USB_Device.open\n"); fprintf_flush(stderr, "Can't find USB_Device.open\n");
return FALSE; return FALSE;
} }
mid_USB_Dev_close = env->GetStaticMethodID(cls_USB_Device, "close", "()V"); mid_USB_Dev_close = env->GetStaticMethodID(cls_USB_Device, "close", "()V");
if (mid_USB_Dev_close == 0) { if (mid_USB_Dev_close == 0) {
fprintf(stderr, "Can't find USB_Device.close\n"); fprintf_flush(stderr, "Can't find USB_Device.close\n");
return FALSE; return FALSE;
} }
mid_USB_Dev_reset = env->GetStaticMethodID(cls_USB_Device, "reset", "()V"); mid_USB_Dev_reset = env->GetStaticMethodID(cls_USB_Device, "reset", "()V");
if (mid_USB_Dev_reset == 0) { if (mid_USB_Dev_reset == 0) {
fprintf(stderr, "Can't find USB_Device.reset\n"); fprintf_flush(stderr, "Can't find USB_Device.reset\n");
return FALSE; return FALSE;
} }
// BDI555 // BDI555
mid_BDI555_break_ = env->GetStaticMethodID(cls_BDI555, "break_", "()V"); mid_BDI555_break_ = env->GetStaticMethodID(cls_BDI555, "break_", "()V");
if (mid_BDI555_break_ == 0) { if (mid_BDI555_break_ == 0) {
fprintf(stderr, "Can't find BDI555.break_\n"); fprintf_flush(stderr, "Can't find BDI555.break_\n");
return FALSE; return FALSE;
} }
mid_BDI555_go = env->GetStaticMethodID(cls_BDI555, "go", "()V"); mid_BDI555_go = env->GetStaticMethodID(cls_BDI555, "go", "()V");
if (mid_BDI555_go == 0) { if (mid_BDI555_go == 0) {
fprintf(stderr, "Can't find BDI555.go\n"); fprintf_flush(stderr, "Can't find BDI555.go\n");
return FALSE; return FALSE;
} }
mid_BDI555_reset_target = env->GetStaticMethodID(cls_BDI555, "reset_target", "()V"); mid_BDI555_reset_target = env->GetStaticMethodID(cls_BDI555, "reset_target", "()V");
if (mid_BDI555_reset_target == 0) { if (mid_BDI555_reset_target == 0) {
fprintf(stderr, "Can't find BDI555.reset_target\n"); fprintf_flush(stderr, "Can't find BDI555.reset_target\n");
return FALSE; return FALSE;
} }
mid_BDI555_isFreezeAsserted = env->GetStaticMethodID(cls_BDI555, "isFreezeAsserted", "()Z"); mid_BDI555_isFreezeAsserted = env->GetStaticMethodID(cls_BDI555, "isFreezeAsserted", "()Z");
if (mid_BDI555_isFreezeAsserted == 0) { if (mid_BDI555_isFreezeAsserted == 0) {
fprintf(stderr, "Can't find BDI555.isFreezeAsserted\n"); fprintf_flush(stderr, "Can't find BDI555.isFreezeAsserted\n");
return FALSE; return FALSE;
} }
mid_BDI555_startFastDownload = env->GetStaticMethodID(cls_BDI555, "startFastDownload", "(I)V"); mid_BDI555_startFastDownload = env->GetStaticMethodID(cls_BDI555, "startFastDownload", "(I)V");
if (mid_BDI555_startFastDownload == 0) { if (mid_BDI555_startFastDownload == 0) {
fprintf(stderr, "Can't find BDI555.startFastDownload\n"); fprintf_flush(stderr, "Can't find BDI555.startFastDownload\n");
return FALSE; return FALSE;
} }
mid_BDI555_fastDownload = env->GetStaticMethodID(cls_BDI555, "fastDownload", "([II)V"); mid_BDI555_fastDownload = env->GetStaticMethodID(cls_BDI555, "fastDownload", "([II)V");
if (mid_BDI555_fastDownload == 0) { if (mid_BDI555_fastDownload == 0) {
fprintf(stderr, "Can't find BDI555.fastDownload\n"); fprintf_flush(stderr, "Can't find BDI555.fastDownload\n");
return FALSE; return FALSE;
} }
mid_BDI555_stopFastDownload = env->GetStaticMethodID(cls_BDI555, "stopFastDownload", "()V"); mid_BDI555_stopFastDownload = env->GetStaticMethodID(cls_BDI555, "stopFastDownload", "()V");
if (mid_BDI555_stopFastDownload == 0) { if (mid_BDI555_stopFastDownload == 0) {
fprintf(stderr, "Can't find BDI555.stopFastDownload\n"); fprintf_flush(stderr, "Can't find BDI555.stopFastDownload\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeMem = env->GetStaticMethodID(cls_BDI555, "writeMem", "(III)V"); mid_BDI555_writeMem = env->GetStaticMethodID(cls_BDI555, "writeMem", "(III)V");
if (mid_BDI555_writeMem == 0) { if (mid_BDI555_writeMem == 0) {
fprintf(stderr, "Can't find BDI555.writeMem\n"); fprintf_flush(stderr, "Can't find BDI555.writeMem\n");
return FALSE; return FALSE;
} }
mid_BDI555_readMem = env->GetStaticMethodID(cls_BDI555, "readMem", "(II)I"); mid_BDI555_readMem = env->GetStaticMethodID(cls_BDI555, "readMem", "(II)I");
if (mid_BDI555_readMem == 0) { if (mid_BDI555_readMem == 0) {
fprintf(stderr, "Can't find BDI555.readMem\n"); fprintf_flush(stderr, "Can't find BDI555.readMem\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeMemSeq = env->GetStaticMethodID(cls_BDI555, "writeMemSeq", "(II)V"); mid_BDI555_writeMemSeq = env->GetStaticMethodID(cls_BDI555, "writeMemSeq", "(II)V");
if (mid_BDI555_writeMemSeq == 0) { if (mid_BDI555_writeMemSeq == 0) {
fprintf(stderr, "Can't find BDI555.writeMemSeq\n"); fprintf_flush(stderr, "Can't find BDI555.writeMemSeq\n");
return FALSE; return FALSE;
} }
mid_BDI555_readMemSeq = env->GetStaticMethodID(cls_BDI555, "readMemSeq", "(I)I"); mid_BDI555_readMemSeq = env->GetStaticMethodID(cls_BDI555, "readMemSeq", "(I)I");
if (mid_BDI555_readMemSeq == 0) { if (mid_BDI555_readMemSeq == 0) {
fprintf(stderr, "Can't find BDI555.readMemSeq\n"); fprintf_flush(stderr, "Can't find BDI555.readMemSeq\n");
return FALSE; return FALSE;
} }
mid_BDI555_readGPR = env->GetStaticMethodID(cls_BDI555, "readGPR", "(I)I"); mid_BDI555_readGPR = env->GetStaticMethodID(cls_BDI555, "readGPR", "(I)I");
if (mid_BDI555_readGPR == 0) { if (mid_BDI555_readGPR == 0) {
fprintf(stderr, "Can't find BDI555.readGPR\n"); fprintf_flush(stderr, "Can't find BDI555.readGPR\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeGPR = env->GetStaticMethodID(cls_BDI555, "writeGPR", "(II)V"); mid_BDI555_writeGPR = env->GetStaticMethodID(cls_BDI555, "writeGPR", "(II)V");
if (mid_BDI555_writeGPR == 0) { if (mid_BDI555_writeGPR == 0) {
fprintf(stderr, "Can't find BDI555.writeGPR\n"); fprintf_flush(stderr, "Can't find BDI555.writeGPR\n");
return FALSE; return FALSE;
} }
mid_BDI555_readSPR = env->GetStaticMethodID(cls_BDI555, "readSPR", "(I)I"); mid_BDI555_readSPR = env->GetStaticMethodID(cls_BDI555, "readSPR", "(I)I");
if (mid_BDI555_readSPR == 0) { if (mid_BDI555_readSPR == 0) {
fprintf(stderr, "Can't find BDI555.readSPR\n"); fprintf_flush(stderr, "Can't find BDI555.readSPR\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeSPR = env->GetStaticMethodID(cls_BDI555, "writeSPR", "(II)V"); mid_BDI555_writeSPR = env->GetStaticMethodID(cls_BDI555, "writeSPR", "(II)V");
if (mid_BDI555_writeSPR == 0) { if (mid_BDI555_writeSPR == 0) {
fprintf(stderr, "Can't find BDI555.writeSPR\n"); fprintf_flush(stderr, "Can't find BDI555.writeSPR\n");
return FALSE; return FALSE;
} }
mid_BDI555_readMSR = env->GetStaticMethodID(cls_BDI555, "readMSR", "()I"); mid_BDI555_readMSR = env->GetStaticMethodID(cls_BDI555, "readMSR", "()I");
if (mid_BDI555_readMSR == 0) { if (mid_BDI555_readMSR == 0) {
fprintf(stderr, "Can't find BDI555.readMSR\n"); fprintf_flush(stderr, "Can't find BDI555.readMSR\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeMSR = env->GetStaticMethodID(cls_BDI555, "writeMSR", "(I)V"); mid_BDI555_writeMSR = env->GetStaticMethodID(cls_BDI555, "writeMSR", "(I)V");
if (mid_BDI555_writeMSR == 0) { if (mid_BDI555_writeMSR == 0) {
fprintf(stderr, "Can't find BDI555.writeMSR\n"); fprintf_flush(stderr, "Can't find BDI555.writeMSR\n");
return FALSE; return FALSE;
} }
mid_BDI555_readFPR = env->GetStaticMethodID(cls_BDI555, "readFPR", "(II)J"); mid_BDI555_readFPR = env->GetStaticMethodID(cls_BDI555, "readFPR", "(II)J");
if (mid_BDI555_readFPR == 0) { if (mid_BDI555_readFPR == 0) {
fprintf(stderr, "Can't find BDI555.readFPR\n"); fprintf_flush(stderr, "Can't find BDI555.readFPR\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeFPR = env->GetStaticMethodID(cls_BDI555, "writeFPR", "(IIJ)V"); mid_BDI555_writeFPR = env->GetStaticMethodID(cls_BDI555, "writeFPR", "(IIJ)V");
if (mid_BDI555_writeFPR == 0) { if (mid_BDI555_writeFPR == 0) {
fprintf(stderr, "Can't find BDI555.writeFPR\n"); fprintf_flush(stderr, "Can't find BDI555.writeFPR\n");
return FALSE; return FALSE;
} }
mid_BDI555_readCR = env->GetStaticMethodID(cls_BDI555, "readCR", "()I"); mid_BDI555_readCR = env->GetStaticMethodID(cls_BDI555, "readCR", "()I");
if (mid_BDI555_readCR == 0) { if (mid_BDI555_readCR == 0) {
fprintf(stderr, "Can't find BDI555.readCR\n"); fprintf_flush(stderr, "Can't find BDI555.readCR\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeCR = env->GetStaticMethodID(cls_BDI555, "writeCR", "(I)V"); mid_BDI555_writeCR = env->GetStaticMethodID(cls_BDI555, "writeCR", "(I)V");
if (mid_BDI555_writeCR == 0) { if (mid_BDI555_writeCR == 0) {
fprintf(stderr, "Can't find BDI555.writeCR\n"); fprintf_flush(stderr, "Can't find BDI555.writeCR\n");
return FALSE; return FALSE;
} }
mid_BDI555_readFPSCR = env->GetStaticMethodID(cls_BDI555, "readFPSCR", "()I"); mid_BDI555_readFPSCR = env->GetStaticMethodID(cls_BDI555, "readFPSCR", "()I");
if (mid_BDI555_readFPSCR == 0) { if (mid_BDI555_readFPSCR == 0) {
fprintf(stderr, "Can't find BDI555.readFPSCR\n"); fprintf_flush(stderr, "Can't find BDI555.readFPSCR\n");
return FALSE; return FALSE;
} }
mid_BDI555_writeFPSCR = env->GetStaticMethodID(cls_BDI555, "writeFPSCR", "(I)V"); mid_BDI555_writeFPSCR = env->GetStaticMethodID(cls_BDI555, "writeFPSCR", "(I)V");
if (mid_BDI555_writeFPSCR == 0) { if (mid_BDI555_writeFPSCR == 0) {
fprintf(stderr, "Can't find BDI555.writeFPSCR\n"); fprintf_flush(stderr, "Can't find BDI555.writeFPSCR\n");
return FALSE; return FALSE;
} }
mid_BDI555_isTargetInDebugMode = env->GetStaticMethodID(cls_BDI555, "isTargetInDebugMode", "()Z"); mid_BDI555_isTargetInDebugMode = env->GetStaticMethodID(cls_BDI555, "isTargetInDebugMode", "()Z");
if (mid_BDI555_isTargetInDebugMode == 0) { if (mid_BDI555_isTargetInDebugMode == 0) {
fprintf(stderr, "Can't find BDI555.isTargetInDebugMode\n"); fprintf_flush(stderr, "Can't find BDI555.isTargetInDebugMode\n");
return FALSE; return FALSE;
} }
mid_BDI555_setGpr31 = env->GetStaticMethodID(cls_BDI555, "setGpr31", "(I)V"); mid_BDI555_setGpr31 = env->GetStaticMethodID(cls_BDI555, "setGpr31", "(I)V");
if (mid_BDI555_setGpr31 == 0) { if (mid_BDI555_setGpr31 == 0) {
fprintf(stderr, "Can't find BDI555.setGpr31\n"); fprintf_flush(stderr, "Can't find BDI555.setGpr31\n");
return FALSE; return FALSE;
} }
// BDI332 // BDI332
mid_BDI332_nopsToLegalCmd = env->GetStaticMethodID(cls_BDI332, "nopsToLegalCmd", "()V"); mid_BDI332_nopsToLegalCmd = env->GetStaticMethodID(cls_BDI332, "nopsToLegalCmd", "()V");
if (mid_BDI332_nopsToLegalCmd == 0) { if (mid_BDI332_nopsToLegalCmd == 0) {
fprintf(stderr, "Can't find BDI332.nopsToLegalCmd\n"); fprintf_flush(stderr, "Can't find BDI332.nopsToLegalCmd\n");
return FALSE; return FALSE;
} }
mid_BDI332_break_ = env->GetStaticMethodID(cls_BDI332, "break_", "()V"); mid_BDI332_break_ = env->GetStaticMethodID(cls_BDI332, "break_", "()V");
if (mid_BDI332_break_ == 0) { if (mid_BDI332_break_ == 0) {
fprintf(stderr, "Can't find BDI332.break_\n"); fprintf_flush(stderr, "Can't find BDI332.break_\n");
return FALSE; return FALSE;
} }
mid_BDI332_go = env->GetStaticMethodID(cls_BDI332, "go", "()V"); mid_BDI332_go = env->GetStaticMethodID(cls_BDI332, "go", "()V");
if (mid_BDI332_go == 0) { if (mid_BDI332_go == 0) {
fprintf(stderr, "Can't find BDI332.go\n"); fprintf_flush(stderr, "Can't find BDI332.go\n");
return FALSE; return FALSE;
} }
mid_BDI332_reset_target = env->GetStaticMethodID(cls_BDI332, "reset_target", "()V"); mid_BDI332_reset_target = env->GetStaticMethodID(cls_BDI332, "reset_target", "()V");
if (mid_BDI332_reset_target == 0) { if (mid_BDI332_reset_target == 0) {
fprintf(stderr, "Can't find BDI332.reset_target\n"); fprintf_flush(stderr, "Can't find BDI332.reset_target\n");
return FALSE; return FALSE;
} }
mid_BDI332_reset_peripherals = env->GetStaticMethodID(cls_BDI332, "reset_peripherals", "()V"); mid_BDI332_reset_peripherals = env->GetStaticMethodID(cls_BDI332, "reset_peripherals", "()V");
if (mid_BDI332_reset_peripherals == 0) { if (mid_BDI332_reset_peripherals == 0) {
fprintf(stderr, "Can't find BDI332.reset_peripherals\n"); fprintf_flush(stderr, "Can't find BDI332.reset_peripherals\n");
return FALSE; return FALSE;
} }
mid_BDI332_isFreezeAsserted = env->GetStaticMethodID(cls_BDI332, "isFreezeAsserted", "()Z"); mid_BDI332_isFreezeAsserted = env->GetStaticMethodID(cls_BDI332, "isFreezeAsserted", "()Z");
if (mid_BDI332_isFreezeAsserted == 0) { if (mid_BDI332_isFreezeAsserted == 0) {
fprintf(stderr, "Can't find BDI332.isFreezeAsserted\n"); fprintf_flush(stderr, "Can't find BDI332.isFreezeAsserted\n");
return FALSE; return FALSE;
} }
mid_BDI332_fillMem = env->GetStaticMethodID(cls_BDI332, "fillMem", "([II)V"); mid_BDI332_fillMem = env->GetStaticMethodID(cls_BDI332, "fillMem", "([II)V");
if (mid_BDI332_fillMem == 0) { if (mid_BDI332_fillMem == 0) {
fprintf(stderr, "Can't find BDI332.fillMem\n"); fprintf_flush(stderr, "Can't find BDI332.fillMem\n");
return FALSE; return FALSE;
} }
mid_BDI332_dumpMem = env->GetStaticMethodID(cls_BDI332, "dumpMem", "(I)[I"); mid_BDI332_dumpMem = env->GetStaticMethodID(cls_BDI332, "dumpMem", "(I)[I");
if (mid_BDI332_dumpMem == 0) { if (mid_BDI332_dumpMem == 0) {
fprintf(stderr, "Can't find BDI332.dumpMem\n"); fprintf_flush(stderr, "Can't find BDI332.dumpMem\n");
return FALSE; return FALSE;
} }
mid_BDI332_writeMem = env->GetStaticMethodID(cls_BDI332, "writeMem", "(III)V"); mid_BDI332_writeMem = env->GetStaticMethodID(cls_BDI332, "writeMem", "(III)V");
if (mid_BDI332_writeMem == 0) { if (mid_BDI332_writeMem == 0) {
fprintf(stderr, "Can't find BDI332.writeMem\n"); fprintf_flush(stderr, "Can't find BDI332.writeMem\n");
return FALSE; return FALSE;
} }
mid_BDI332_readMem = env->GetStaticMethodID(cls_BDI332, "readMem", "(II)I"); mid_BDI332_readMem = env->GetStaticMethodID(cls_BDI332, "readMem", "(II)I");
if (mid_BDI332_readMem == 0) { if (mid_BDI332_readMem == 0) {
fprintf(stderr, "Can't find BDI332.readMem\n"); fprintf_flush(stderr, "Can't find BDI332.readMem\n");
return FALSE; return FALSE;
} }
mid_BDI332_readUserReg = env->GetStaticMethodID(cls_BDI332, "readUserReg", "(I)I"); mid_BDI332_readUserReg = env->GetStaticMethodID(cls_BDI332, "readUserReg", "(I)I");
if (mid_BDI332_readUserReg == 0) { if (mid_BDI332_readUserReg == 0) {
fprintf(stderr, "Can't find BDI332.readUserReg\n"); fprintf_flush(stderr, "Can't find BDI332.readUserReg\n");
return FALSE; return FALSE;
} }
mid_BDI332_writeUserReg = env->GetStaticMethodID(cls_BDI332, "writeUserReg", "(II)V"); mid_BDI332_writeUserReg = env->GetStaticMethodID(cls_BDI332, "writeUserReg", "(II)V");
if (mid_BDI332_writeUserReg == 0) { if (mid_BDI332_writeUserReg == 0) {
fprintf(stderr, "Can't find BDI332.writeUserReg\n"); fprintf_flush(stderr, "Can't find BDI332.writeUserReg\n");
return FALSE; return FALSE;
} }
mid_BDI332_readUserReg = env->GetStaticMethodID(cls_BDI332, "readUserReg", "(I)I"); mid_BDI332_readUserReg = env->GetStaticMethodID(cls_BDI332, "readUserReg", "(I)I");
if (mid_BDI332_readUserReg == 0) { if (mid_BDI332_readUserReg == 0) {
fprintf(stderr, "Can't find BDI332.readUserReg\n"); fprintf_flush(stderr, "Can't find BDI332.readUserReg\n");
return FALSE; return FALSE;
} }
mid_BDI332_writeSysReg = env->GetStaticMethodID(cls_BDI332, "writeSysReg", "(II)V"); mid_BDI332_writeSysReg = env->GetStaticMethodID(cls_BDI332, "writeSysReg", "(II)V");
if (mid_BDI332_writeSysReg == 0) { if (mid_BDI332_writeSysReg == 0) {
fprintf(stderr, "Can't find BDI332.writeSysReg\n"); fprintf_flush(stderr, "Can't find BDI332.writeSysReg\n");
return FALSE; return FALSE;
} }
mid_BDI332_readSysReg = env->GetStaticMethodID(cls_BDI332, "readSysReg", "(I)I"); mid_BDI332_readSysReg = env->GetStaticMethodID(cls_BDI332, "readSysReg", "(I)I");
if (mid_BDI332_readSysReg == 0) { if (mid_BDI332_readSysReg == 0) {
fprintf(stderr, "Can't find BDI332.readSysReg\n"); fprintf_flush(stderr, "Can't find BDI332.readSysReg\n");
return FALSE; return FALSE;
} }
mid_BDI332_isTargetInDebugMode = env->GetStaticMethodID(cls_BDI332, "isTargetInDebugMode", "()Z"); mid_BDI332_isTargetInDebugMode = env->GetStaticMethodID(cls_BDI332, "isTargetInDebugMode", "()Z");
if (mid_BDI332_isTargetInDebugMode == 0) { if (mid_BDI332_isTargetInDebugMode == 0) {
fprintf(stderr, "Can't find BDI332.isTargetInDebugMode\n"); fprintf_flush(stderr, "Can't find BDI332.isTargetInDebugMode\n");
return FALSE; return FALSE;
} }
// Redirect Class // Redirect Class
mid_Redirect_redirect = env->GetStaticMethodID(cls_Redirect, "redirect", "()V"); mid_Redirect_redirect = env->GetStaticMethodID(cls_Redirect, "redirect", "()V");
if (mid_Redirect_redirect == 0) { if (mid_Redirect_redirect == 0) {
fprintf(stderr, "Can't find Redirect.redirect\n"); fprintf_flush(stderr, "Can't find Redirect.redirect\n");
return FALSE; return FALSE;
} }
// Call redirect
env->CallStaticVoidMethod(cls_Redirect, mid_Redirect_redirect);
// Uart0 Class // Uart0 Class
mid_Uart0_write = env->GetStaticMethodID(cls_Uart0, "write", "([BI)Z"); mid_Uart0_write = env->GetStaticMethodID(cls_Uart0, "write", "([BI)Z");
if (mid_Uart0_write == 0) { if (mid_Uart0_write == 0) {
fprintf(stderr, "Can't find Uart0.write\n"); fprintf_flush(stderr, "Can't find Uart0.write\n");
return FALSE; return FALSE;
} }
mid_Uart0_read = env->GetStaticMethodID(cls_Uart0, "read", "()[B"); mid_Uart0_read = env->GetStaticMethodID(cls_Uart0, "read", "()[B");
if (mid_Uart0_read == 0) { if (mid_Uart0_read == 0) {
fprintf(stderr, "Can't find Uart0.read\n"); fprintf_flush(stderr, "Can't find Uart0.read\n");
return FALSE; return FALSE;
} }
jvm_mIDs_done = TRUE;
} else {
fprintf_flush(stdout, "Method IDs already created -> trying to redirect ouput streams\n");
} }
if (!jvm_redirection_done) {
// Call redirect
env->CallStaticVoidMethod(cls_Redirect, mid_Redirect_redirect);
jvm_redirection_done = TRUE;
} else {
fprintf_flush(stdout, "Redirection already done -> everything successfully set up!\n");
}
return TRUE; return TRUE;
} }
@@ -452,7 +515,10 @@ EXPORT int checkForExceptions() {
return FALSE; return FALSE;
} }
// USB_Device methods /* USB_Device methods
*
* For documentatione see the java doc.
*/
EXPORT void USB_Device_open() EXPORT void USB_Device_open()
{ {
env->CallStaticVoidMethod(cls_USB_Device, mid_USB_Dev_open); env->CallStaticVoidMethod(cls_USB_Device, mid_USB_Dev_open);
@@ -468,7 +534,10 @@ EXPORT void USB_Device_reset()
env->CallStaticVoidMethod(cls_USB_Device, mid_USB_Dev_reset); env->CallStaticVoidMethod(cls_USB_Device, mid_USB_Dev_reset);
} }
// BDI 555 methods /* BDI 555 methods
*
* For documentatione see the java doc.
*/
EXPORT void BDI555_break_() EXPORT void BDI555_break_()
{ {
env->CallStaticVoidMethod(cls_BDI555, mid_BDI555_break_); env->CallStaticVoidMethod(cls_BDI555, mid_BDI555_break_);
@@ -613,7 +682,10 @@ EXPORT void BDI555_setGpr31(int gpr31)
} }
// BDI 332 methods /* BDI 332 methods
*
* For documentatione see the java doc.
*/
EXPORT void BDI332_nopsToLegalCmd() EXPORT void BDI332_nopsToLegalCmd()
{ {
env->CallStaticVoidMethod(cls_BDI332, mid_BDI332_nopsToLegalCmd); env->CallStaticVoidMethod(cls_BDI332, mid_BDI332_nopsToLegalCmd);
@@ -660,7 +732,7 @@ EXPORT void BDI332_fillMem(int downloadData[], int dataLength)
return; return;
} }
// for (int i = 0; i < dataLength; ++i) { // for (int i = 0; i < dataLength; ++i) {
// printf("data %d: %x\n", i, downloadData[i]); // fprintf_flush(stdout, ("data %d: %x\n", i, downloadData[i]);
// } // }
env->SetIntArrayRegion(jdata, 0, dataLength, (jint*) downloadData); env->SetIntArrayRegion(jdata, 0, dataLength, (jint*) downloadData);
@@ -722,6 +794,11 @@ EXPORT BOOL BDI332_isTargetInDebugMode()
return (isAsserted != JNI_FALSE); return (isAsserted != JNI_FALSE);
} }
/*
* UART functions
*
* For documentatione see the java doc.
*/
EXPORT int UART0_read(char result[]) EXPORT int UART0_read(char result[])
{ {
jbyteArray byteArray; jbyteArray byteArray;
@@ -754,7 +831,7 @@ EXPORT int UART0_write(char data[], int dataLength)
return FALSE; return FALSE;
} }
// for (int i = 0; i < dataLength; ++i) { // for (int i = 0; i < dataLength; ++i) {
// printf("data %d: %x\n", i, data[i]); // fprintf_flush(stdout, ("data %d: %x\n", i, data[i]);
// } // }
env->SetByteArrayRegion(jdata, 0, dataLength, (jbyte*) data); env->SetByteArrayRegion(jdata, 0, dataLength, (jbyte*) data);

32
JNIdll/makefile
View File

@@ -1,34 +1,12 @@
EXESRC=BDI_exe.cpp
SRC=invoke.cpp
DLLSRC=BDI_dll.cpp DLLSRC=BDI_dll.cpp
DLL=BDI.dll DLL=BDI.dll
DEF=BDI.def DEF=BDI.def
IMPLIB=BDI555.lib
IMPLIBA=libbdi555.a
JVMLIBA=libjvm.a JVMLIBA=libjvm.a
OBJ=$(SRC:.c=.o) # replaces the .c from SRC with .o OBJ=$(SRC:.c=.o) # replaces the .c from SRC with .o
EXE=BDI_exe.exe
INVOKE=invoke.exe
JAVA_HOME="C:/Program Files/Java/jdk1.5.0_04" JAVA_HOME="C:/Program Files/Java/jdk1.5.0_04"
CC=gcc CC=gcc
RM=rm RM=rm
REIMP=reimp
all: $(INVOKE) # all is dependent on $(EXE) to be complete
$(INVOKE): $(OBJ) # $(EXE) is dependent on all of the files in $(OBJ) to exist
$(CC) -Wall -D_JNI_IMPLEMENTATION_ \
-I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/win32 \
-o $(INVOKE) $(SRC) $(JVMLIBA)
exe: $(EXE) # all is dependent on $(EXE) to be complete
$(EXE): $(OBJ) # $(EXE) is dependent on all of the files in $(OBJ) to exist
$(CC) -Wall -D_JNI_IMPLEMENTATION_ \
-I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/win32 \
-o $(EXE) $(EXESRC) $(JVMLIBA)
cleanExe:
$(RM) $(EXE)
dll: $(DLL) dll: $(DLL)
$(DLL): $(DLLSRC) $(DLL): $(DLLSRC)
@@ -42,15 +20,5 @@ $(DLL): $(DLLSRC)
# -I$(JAVAPATH)/include -I$(JAVAPATH)/include/win32 \ # -I$(JAVAPATH)/include -I$(JAVAPATH)/include/win32 \
# -shared $(DLLSRC) -o $(DLL) $(JVMLIBA) # -shared $(DLLSRC) -o $(DLL) $(JVMLIBA)
impLib: $(IMPLIB)
$(IMPLIB): $(DEF)
dlltool -U -d $(DEF) -l $(IMPLIB)
lib: $(IMPLIBA)
$(IMPLIBA): $(DEF)
lib /machine:i386 /def:$(DEF)
$(REIMP) $(IMPLIB)
clean: clean:
$(RM) $(DLL) $(RM) $(DLL)
$(RM) $(EXE)