static void ConnADBTasks() {
int res;
if (!ADBAttached()) {
adb_state = STATE_ADB_DISCONNECTED;
return;
}
switch (adb_state) {
case STATE_ADB_DISCONNECTED:
if (ADBAttached()) {
ADBInit();
ADBFileInit();
adb_state = STATE_ADB_INITIALIZING;
}
break;
case STATE_ADB_INITIALIZING:
case STATE_ADB_INITIALIZED:
res = ADBTasks();
if (res == -1) {
log_printf("Error occured. Resetting Android USB.");
USBHostAndroidReset();
break;
}
if (res == 1) {
ADBFileTasks();
adb_state = STATE_ADB_INITIALIZED;
} else if (res == 0) {
adb_state = STATE_ADB_INITIALIZING;
}
break;
}
}
int ADBTasks() {
ADB_RESULT adb_res;
UINT32 cmd, arg0, arg1, data_len;
void* recv_data;
if (adb_conn_state > ADB_CONN_STATE_WAIT_ATTACH) {
if (!ADBAttached()) {
// detached
ADBReset();
return 0;
}
ADBPacketTasks();
if (adb_buffer_refcount > 0) {
if ((adb_res = ADBPacketRecvStatus(&cmd, &arg0, &arg1, &recv_data, &data_len)) != ADB_RESULT_BUSY) {
if (adb_res == ADB_RESULT_ERROR) {
CHANGE_STATE(adb_conn_state, ADB_CONN_STATE_ERROR);
} else {
ADBHandlePacket(cmd, arg0, arg1, recv_data, data_len);
}
ADBBufferUnref();
}
}
}
switch (adb_conn_state) {
case ADB_CONN_STATE_WAIT_ATTACH:
if (ADBAttached()) {
log_printf("Device attached.");
ADBPacketReset();
adb_buffer_refcount = 1;
ADBPacketRecv(); // start receiving
ADBPacketSend(ADB_CNXN, ADB_VERSION, ADB_PACKET_MAX_RECV_DATA_BYTES, ADB_HOSTNAME_STRING, strlen(ADB_HOSTNAME_STRING) + 1);
CHANGE_STATE(adb_conn_state, ADB_CONN_STATE_WAIT_CONNECT);
}
break;
case ADB_CONN_STATE_WAIT_CONNECT:
break;
case ADB_CONN_STATE_CONNECTED:
ADBChannelTasks();
break;
case ADB_CONN_STATE_ERROR:
log_printf("Error occured. Resetting.");
ADBReset();
return -1;
}
return ADBConnected();
}
int main() {
CFGCONbits.JTAGEN = 0; // turn off JTAG, get back those pins for IO use
// set PIC32to max computing power
DEBUGLED = 0;
// enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
INTEnableInterrupts();
PIC32MX250_setup_pins();
SYSTEMConfigPerformance(SYS_FREQ);
setTimer2(OUTPUT_FREQ); //
setupTimer3(BUFFER_FREQ);
initPWM(); //Initializing PWM on OC3.
// Initialize texture buffer and index to zero
int i;
tBuff.Index = 0; //init to zero
tBuff.On = 0; //turn off
tBuff.Length0 = 0; //start with zero length
tBuff.Length1 = 0; //start with zero length
tBuff.Front = 0;
for (i = 0; i < MAX_BUFFER_LENGTH; i++) {
tBuff.Buff0[i] = 0; //init entire buffer to zero
tBuff.Buff1[i] = 0; //init entire buffer to zero
}
// Initialize the USB host
ConnectionInit();
DEBUGLED = 1;
//Main USB State Machine
while (1) {
// Keep the USB connection running;
// Handle incoming data and manage outgoing data.
ConnectionTasks();
// Main state machine
switch (state) {
case STATE_INIT:
state = STATE_WAITING;
h = INVALID_CHANNEL_HANDLE;
break;
case STATE_WAITING:
DEBUGLED = 0;
if (ADBAttached()) {
state = STATE_CONNECTING;
}
break;
case STATE_CONNECTING:
if (ADBConnected()) {
// Open a channel to the Android device
// See "adb.h" in libadb for more details
// (I don't think the name tcp:4545 matters)
h = ADBOpen("tcp:4545", &ADBCallback);
if (h != INVALID_CHANNEL_HANDLE) {
state = STATE_CONNECTED;
WriteCoreTimer(0);
// Send plaintext and let the recipient do formatting
ADBWrite(h & 0xFF, "Hello from TPAD!", 17);
}
}
break;
case STATE_CONNECTED:
DEBUGLED = 1;
if (!ADBAttached()) {
state = STATE_INIT;
}
if (ADBChannelReady(h)) {
// Execute tasks that rely on the Android-PIC32 connection
// Here we will just wait for messages to come in and be handled below
}
// Timeout timer. If the coretimer is not reset by a keepalive command from the Android, the PIC will reset the USB communications
if (ReadCoreTimer() > 200000000) {
state = STATE_INIT;
}
break;
} // end state machine
} // end while loop
return 0;
}
int main() {
ADB_FILE_HANDLE f;
ADB_CHANNEL_HANDLE h;
#ifdef SIGNAL_AFTER_BAD_RESET
if (RCON & 0b1100001001000000) {
SignalRcon();
}
#endif
log_init();
log_printf("Hello from Bootloader!!!");
InitializeSystem();
BootloaderConnInit();
while (1) {
BOOL connected = BootloaderConnTasks();
mLED_0 = (state == MAIN_STATE_ERROR) ? (led_counter++ >> 13) : !connected;
if (!connected) {
state = MAIN_STATE_WAIT_CONNECT;
}
switch(state) {
case MAIN_STATE_WAIT_CONNECT:
if (connected) {
log_printf("Device connected!");
if (ADBAttached()) {
log_printf("ADB attached - attempting firmware upgrade");
state = MAIN_STATE_WAIT_ADB_READY;
} else {
log_printf("ADB not attached - skipping boot sequence");
state = MAIN_STATE_RUN_APP;
}
}
break;
case MAIN_STATE_WAIT_ADB_READY:
if (ADBConnected()) {
log_printf("ADB connected - starting boot sequence");
manager_path = DUMPSYS_BUSY;
DumpsysInit();
h = ADBOpen("shell:dumpsys package ioio.manager", &RecvDumpsys);
state = MAIN_STATE_FIND_PATH;
}
break;
case MAIN_STATE_FIND_PATH_DONE:
fingerprint_size = 0;
strcpy(filepath, manager_path);
strcat(filepath, "/files/" PLATFORM_ID ".fp");
f = ADBFileRead(filepath, &FileRecvFingerprint);
state = MAIN_STATE_WAIT_RECV_FP;
break;
case MAIN_STATE_FP_FAILED:
#ifdef BYPASS_SECURITY
state = MAIN_STATE_AUTH_PASSED;
break;
#endif
auth_result = AUTH_BUSY;
AuthInit();
f = ADBFileRead("/data/system/packages.xml", &FileRecvPackages);
state = MAIN_STATE_AUTH_MANAGER;
break;
case MAIN_STATE_AUTH_PASSED:
if (!EraseFingerprint()) {
state = MAIN_STATE_ERROR;
} else {
IOIOFileInit();
strcpy(filepath, manager_path);
strcat(filepath, "/files/" PLATFORM_ID ".ioio");
f = ADBFileRead(filepath, &FileRecvImage);
state = MAIN_STATE_WAIT_RECV_IMAGE;
}
break;
case MAIN_STATE_RECV_IMAGE_DONE:
if (WriteFingerprint()) {
state = MAIN_STATE_RUN_APP;
} else {
state = MAIN_STATE_ERROR;
}
break;
case MAIN_STATE_RUN_APP:
BootloaderConnResetUSB();
pass_usb_to_app = 1;
log_printf("Running app...");
__asm__("goto __APP_RESET");
default:
break; // do nothing
}
}
return 0;
}
