From 550c41f70f5ff6de8210c9ffd7720f40616a4886 Mon Sep 17 00:00:00 2001 From: Cuyler36 <24523422+Cuyler36@users.noreply.github.com> Date: Wed, 10 Jul 2024 04:14:24 -0400 Subject: [PATCH] Implement & link padmgr --- config/rel_slices.yml | 4 + include/libultra/osContPad.h | 59 +++++- include/libultra/os_pfs.h | 30 +++ include/padmgr.h | 38 +++- src/padmgr.c | 372 +++++++++++++++++++++++++++++++++++ src/zurumode.c | 332 +++++++++++++++---------------- 6 files changed, 652 insertions(+), 183 deletions(-) create mode 100644 include/libultra/os_pfs.h create mode 100644 src/padmgr.c diff --git a/config/rel_slices.yml b/config/rel_slices.yml index f5705fbc..785d61a6 100644 --- a/config/rel_slices.yml +++ b/config/rel_slices.yml @@ -360,6 +360,10 @@ main.c: .text: [0x80407AE8, 0x80407CF4] .data: [0x8065F110, 0x8065F138] .bss: [0x812F4CC0, 0x812F5038] +padmgr.c: + .text: [0x80407CF4, 0x80408940] + .data: [0x8065F138, 0x8065F150] + .bss: [0x812F5038, 0x812F54A0] sys_math.c: .text: [0x80408940, 0x80408A44] .rodata: [0x806437C0, 0x806437D0] diff --git a/include/libultra/osContPad.h b/include/libultra/osContPad.h index 7192659b..510c7b4b 100644 --- a/include/libultra/osContPad.h +++ b/include/libultra/osContPad.h @@ -4,6 +4,8 @@ #define OS_CONT_PAD #include "types.h" +#include "libultra/os_pfs.h" +#include "dolphin/os/OSMessage.h" #ifdef __cplusplus extern "C" { @@ -11,20 +13,63 @@ extern "C" { #define MAXCONTROLLERS 4 +/* controller errors */ +#define CONT_NO_ERROR 0 +#define CONT_NO_RESPONSE_ERROR 0x8 +#define CONT_OVERRUN_ERROR 0x4 +#define CONT_RANGE_ERROR -1 + +/* Controller type */ +#define CONT_NONE 0x0000 +#define CONT_ABSOLUTE 0x0001 +#define CONT_RELATIVE 0x0002 +#define CONT_JOYPORT 0x0004 +#define CONT_EEPROM 0x8000 +#define CONT_EEP16K 0x4000 +#define CONT_TYPE_MASK 0x1f07 +#define CONT_TYPE_NORMAL 0x0005 +#define CONT_TYPE_MOUSE 0x0002 +#define CONT_TYPE_VOICE 0x0100 + +/* Controller status */ + +#define CONT_CARD_ON 0x01 +#define CONT_CARD_PULL 0x02 +#define CONT_ADDR_CRC_ER 0x04 +#define CONT_EEPROM_BUSY 0x80 + +/* Controller error number */ + +#define CONT_ERR_NO_CONTROLLER PFS_ERR_NOPACK /* 1 */ +#define CONT_ERR_CONTRFAIL CONT_OVERRUN_ERROR /* 4 */ +#define CONT_ERR_INVALID PFS_ERR_INVALID /* 5 */ +#define CONT_ERR_DEVICE PFS_ERR_DEVICE /* 11 */ +#define CONT_ERR_NOT_READY 12 +#define CONT_ERR_VOICE_MEMORY 13 +#define CONT_ERR_VOICE_WORD 14 +#define CONT_ERR_VOICE_NO_RESPONSE 15 + typedef struct { - u16 type; - u8 status; - u8 errno; + u16 type; + u8 status; + u8 errno; } OSContStatus; /* sizeof(OSContPad) == 6 */ typedef struct { - /* 0x00 */ u16 button; - /* 0x02 */ s8 stick_x; - /* 0x03 */ s8 stick_y; - /* 0x04 */ u8 errno; + /* 0x00 */ u16 button; + /* 0x02 */ s8 stick_x; + /* 0x03 */ s8 stick_y; + /* 0x04 */ u8 errno; } OSContPad; +extern s32 osContInit(OSMessageQueue* mq, u8* pattern_p, OSContStatus* status); +extern s32 osContStartQuery(OSMessageQueue* mq); +extern s32 osContStartReadData(OSMessageQueue* mq); +extern void osContGetQuery(OSContStatus* status); +extern s32 osContSetCh(u8 num_controllers); +extern void osContGetReadData(OSContPad* pad); + #ifdef __cplusplus } #endif diff --git a/include/libultra/os_pfs.h b/include/libultra/os_pfs.h new file mode 100644 index 00000000..085cd656 --- /dev/null +++ b/include/libultra/os_pfs.h @@ -0,0 +1,30 @@ +#ifndef OS_PFS_H +#define OS_PFS_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* File System error number */ + +#define PFS_ERR_NOPACK 1 /* no memory card is plugged or */ +#define PFS_ERR_NEW_PACK 2 /* ram pack has been changed to a different one */ +#define PFS_ERR_INCONSISTENT 3 /* need to run Pfschecker*/ +#define PFS_ERR_CONTRFAIL CONT_OVERRUN_ERROR +#define PFS_ERR_INVALID 5 /* invalid parameter or file not exist*/ +#define PFS_ERR_BAD_DATA 6 /* the data read from pack are bad*/ +#define PFS_DATA_FULL 7 /* no free pages on ram pack*/ +#define PFS_DIR_FULL 8 /* no free directories on ram pack*/ +#define PFS_ERR_EXIST 9 /* file exists*/ +#define PFS_ERR_ID_FATAL 10 /* dead ram pack */ +#define PFS_ERR_DEVICE 11 /* wrong device type*/ +#define PFS_ERR_NO_GBCART 12 /* no gb cartridge (64GB-PAK) */ +#define PFS_ERR_NEW_GBCART 13 /* gb cartridge may be changed */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/padmgr.h b/include/padmgr.h index c6ffc24b..d64676e6 100644 --- a/include/padmgr.h +++ b/include/padmgr.h @@ -6,6 +6,7 @@ #include "libu64/pad.h" #include "dolphin/os/OSMessage.h" #include "libultra/osThread.h" +#include "libu64/pad.h" #ifdef __cplusplus extern "C" { @@ -13,6 +14,10 @@ extern "C" { #define PADMSGBUFCNT 8 +#define PADMGR_FLAG_HANDLE_RETRACE (1 << 0) +#define PADMGR_FLAG_HANDLE_PRENMI (1 << 1) +#define PADMGR_FLAG_DONE (1 << 2) + enum pads { PAD0, PAD1, @@ -22,6 +27,26 @@ enum pads { PAD_NUM }; +enum { + PADMGR_PAK_NONE, + PADMGR_PAK_RUMBLE, + PADMGR_PAK_CONTROLLER, + PADMGR_PAK_UNK, + + PADMGR_PAK_NUM +}; + +enum { + PADMGR_TYPE_NONE, + PADMGR_TYPE_CONTROLLER, + PADMGR_TYPE_2, + PADMGR_TYPE_MOUSE, + PADMGR_TYPE_VOICE_UNINTIALIZED, + PADMGR_TYPE_VOICE_INITIALIZED, + + PADMGR_TYPE_UNK = 255 +}; + typedef struct { u8 last_command; // PAD_MOTOR_* u8 now_command; // PAD_MOTOR_* @@ -43,22 +68,21 @@ typedef struct { /* 0x0008 */ void* callback_param; /* 0x000C */ void (*callback2)(void*); /* 0x0010 */ void* callback2_param; - /* 0x0014 */ OSContStatus pad_status[MAXCONTROLLERS]; /* 0x0024 */ OSMessage _msg24; /* 0x0028 */ OSMessage _msg28; /* 0x002C */ OSMessage _msgBuf2C[PADMSGBUFCNT]; - /* 0x004C */ OSMessageQueue _msgQueue4C; - /* 0x006C */ OSMessageQueue _msgQueue6C; + /* 0x004C */ OSMessageQueue serial_mq; + /* 0x006C */ OSMessageQueue controller_lock_mq; /* 0x008C */ OSMessageQueue _msgQueue8C; /* 0x00AC */ irqmgr_client_t irqclient; /* 0x00B4 */ u32 _unk0; /* maybe additional value in irqmgr_client_t? */ /* 0x00B8 */ OSThread thread; - /* 0x03C8 */ u8 _tmp[0x60]; // pad_t pads[MAXCONTROLLERS]; // TODO: figure out what's going on here. - /* 0x0428 */ OSContPad n64_pads[MAXCONTROLLERS]; /* Converted from PADStatus via JUTGamePad */ + /* 0x03C8 */ pad_t pads[MAXCONTROLLERS]; + /* 0x0428 */ OSContPad cur_pads[MAXCONTROLLERS]; /* Converted from PADStatus via JUTGamePad */ /* 0x0440 */ u8 num_controllers; - /* 0x0441 */ u8 device_type[4]; - /* 0x0445 */ u8 pak_type[4]; + /* 0x0441 */ u8 device_type[MAXCONTROLLERS]; + /* 0x0445 */ u8 pak_type[MAXCONTROLLERS]; /* 0x044A */ Rumble_t rumble; } padmgr; diff --git a/src/padmgr.c b/src/padmgr.c new file mode 100644 index 00000000..734ed075 --- /dev/null +++ b/src/padmgr.c @@ -0,0 +1,372 @@ +#include "padmgr.h" + +#include "libultra/libultra.h" +#include "m_debug.h" +#include "jsyswrap.h" + +static int frame = 0; +padmgr padmgr_class; +static padmgr* this = &padmgr_class; + +extern OSMessageQueue* padmgr_LockSerialMesgQ(void) { + OSMessageQueue* mq; + + osRecvMesg(&this->serial_mq, (OSMesg)&mq, OS_MESG_BLOCK); + return mq; +} + +extern void padmgr_UnlockSerialMesgQ(OSMessageQueue* mq) { + osSendMesg(&this->serial_mq, (OSMesg)mq, OS_MESG_BLOCK); +} + +static void padmgr_LockContData(void) { + osRecvMesg(&this->controller_lock_mq, NULL, OS_MESG_BLOCK); +} + +static void padmgr_UnlockContData(void) { + osSendMesg(&this->controller_lock_mq, (OSMesg)NULL, OS_MESG_BLOCK); +} + +static void padmgr_RumbleControl(void) { + Motor_t* motor = this->rumble.motors; + int i; + + for (i = 0; i < PAD_CONTROLLER_NUM; i++) { + if (this->device_type[i] == PADMGR_TYPE_CONTROLLER && this->rumble.cooldown_frames == 0) { + if (motor->last_command != motor->now_command) { + if (motor->now_command == PAD_MOTOR_STOP) { + motor->frames = 3; + } else { + motor->frames = 0; + } + + PADControlMotor(i, motor->now_command); + motor->last_command = motor->now_command; + } else { + if (motor->frames != 0) { + motor->frames--; + } + + if (motor->frames != 0) { + PADControlMotor(i, PAD_MOTOR_STOP); + } + } + } + + motor++; + } +} + +static void padmgr_RumbleStop(void) { + static u32 stop_command[PAD_CONTROLLER_NUM] = { PAD_MOTOR_STOP, PAD_MOTOR_STOP, PAD_MOTOR_STOP, PAD_MOTOR_STOP }; + int i; + + PADControlAllMotors(stop_command); + for (i = 0; i < PAD_CONTROLLER_NUM; i++) { + this->rumble.motors[i].last_command = PAD_MOTOR_STOP; + this->rumble.motors[i].now_command = PAD_MOTOR_STOP; + this->rumble.motors[i].frames = 0; + } +} + +extern void padmgr_force_stop_ON(void) { + this->rumble.cooldown_frames = 4; +} + +extern void padmgr_force_stop_OFF(void) { + this->rumble.cooldown_frames = 0; +} + +extern void padmgr_RumbleReset(void) { + this->rumble.cooldown_frames = -3; +} + +extern void padmgr_RumbleSet(int pad, int command) { + this->rumble.motors[pad].now_command = command; + if (command != PAD_MOTOR_RUMBLE) { + this->rumble.rumble_frames = 240; + } +} + +static void padmgr_PakConnectCheck(void) { + static int padno = 0; + int i; + + for (i = 0; i < this->num_controllers; i++) { + padno = (padno + 1) % this->num_controllers; + if (this->device_type[padno] == PADMGR_TYPE_CONTROLLER) { + if (this->pak_type[padno] != PADMGR_PAK_NONE) { + u8 status = this->pad_status[padno].status; + + if ((status & CONT_CARD_PULL) != 0 || (status & CONT_CARD_ON) == 0) { + this->pak_type[padno] = PADMGR_PAK_NONE; + } + } + + if (this->pak_type[padno] == PADMGR_PAK_NONE && (this->pad_status[padno].status & CONT_CARD_ON) != 0) { + this->pak_type[padno] = PADMGR_PAK_UNK; + } + break; + } + } +} + +static void padmgr_HandleDoneReadPadMsg(void) { + pad_t* pad = this->pads; + OSContPad* cur_pad = this->cur_pads; + int now; + int trigger; + int i; + + for (i = 0; i < this->num_controllers; i++) { + pad->last = pad->now; + if (this->device_type[i] == PADMGR_TYPE_CONTROLLER) { + switch (cur_pad->errno) { + case CONT_NO_ERROR: + pad->now = *cur_pad; + if (this->device_type[i] == PADMGR_TYPE_NONE) { + this->device_type[i] = PADMGR_TYPE_CONTROLLER; + } + break; + case CONT_OVERRUN_ERROR: + pad->now = pad->last; + break; + case CONT_NO_RESPONSE_ERROR: + pad->now.button = 0; + pad->now.stick_x = 0; + pad->now.stick_y = 0; + pad->now.errno = cur_pad->errno; + if (this->device_type[i] != PADMGR_TYPE_NONE) { + this->device_type[i] = PADMGR_TYPE_NONE; + this->pak_type[i] = PADMGR_PAK_NONE; + } + break; + } + } else { + pad->now.button = 0; + pad->now.stick_x = 0; + pad->now.stick_y = 0; + pad->now.errno = cur_pad->errno; + } + + /* Update buttons */ + trigger = pad->last.button ^ pad->now.button; + trigger |= GETREG(SREG, 16 + i); + pad->on.button |= (u16)(trigger & pad->now.button); + pad->off.button |= (u16)(trigger & pad->last.button); + + /* Update stick values */ + pad_correct_stick(pad); + pad->on.stick_x += (s8)(pad->now.stick_x - pad->last.stick_x); + pad->on.stick_y += (s8)(pad->now.stick_y - pad->last.stick_y); + + pad++; + cur_pad++; + } +} + +static void padmgr_ConnectCheck(void) { + int pattern = 0; + int i; + + for (i = 0; i < this->num_controllers; i++) { + if (this->pad_status[i].errno == CONT_NO_ERROR) { + int masked_type = this->pad_status[i].type & CONT_TYPE_MASK; + + switch (masked_type) { + case CONT_TYPE_NORMAL: + pattern |= 1 << i; + if (this->device_type[i] == PADMGR_TYPE_NONE) { + this->device_type[i] = PADMGR_TYPE_CONTROLLER; + } + break; + case CONT_TYPE_MOUSE: + if (this->device_type[i] == PADMGR_TYPE_NONE) { + this->device_type[i] = PADMGR_TYPE_MOUSE; + } + break; + case CONT_TYPE_VOICE: + if (this->device_type[i] == PADMGR_TYPE_NONE) { + this->device_type[i] = PADMGR_TYPE_VOICE_UNINTIALIZED; + this->pak_type[i] = PADMGR_PAK_NONE; + } + break; + default: + if (this->device_type[i] == PADMGR_TYPE_NONE) { + this->device_type[i] = PADMGR_TYPE_UNK; + } + break; + } + } else { + if (this->device_type[i] != PADMGR_TYPE_NONE) { + if (this->device_type[i] == PADMGR_TYPE_CONTROLLER) { + this->pak_type[i] = PADMGR_PAK_NONE; + } + + this->device_type[i] = PADMGR_TYPE_NONE; + } + } + } + + this->pad_pattern = pattern; +} + +static void padmgr_HandleRetraceMsg(void) { + OSMessageQueue* serial_mq; + + serial_mq = padmgr_LockSerialMesgQ(); + osContStartReadData(serial_mq); + + if (this->callback != NULL) { + (*this->callback)(this->callback_param); + } + + osRecvMesg(serial_mq, NULL, OS_MESG_BLOCK); + osContGetReadData(this->cur_pads); + + if (this->rumble.reset) { + bzero(this->cur_pads, sizeof(this->cur_pads)); + } + + osContStartQuery(serial_mq); + osRecvMesg(serial_mq, NULL, OS_MESG_BLOCK); + osContGetQuery(this->pad_status); + + padmgr_UnlockSerialMesgQ(serial_mq); + + padmgr_ConnectCheck(); + padmgr_LockContData(); + padmgr_HandleDoneReadPadMsg(); + + if (this->callback2 != NULL) { + (*this->callback2)(this->callback2_param); + } + + padmgr_UnlockContData(); + + if (this->rumble.cooldown_frames != 0) { + if (this->rumble.cooldown_frames > 1) { + this->rumble.cooldown_frames--; + padmgr_RumbleStop(); + } else if (this->rumble.cooldown_frames < 0) { + this->rumble.cooldown_frames++; + padmgr_RumbleStop(); + } + } else if (this->rumble.rumble_frames == 0) { + padmgr_RumbleStop(); + } else if (this->rumble.reset == FALSE) { + padmgr_RumbleControl(); + this->rumble.rumble_frames--; + } + + serial_mq = padmgr_LockSerialMesgQ(); + padmgr_PakConnectCheck(); + padmgr_UnlockSerialMesgQ(serial_mq); + frame++; +} + +static void padmgr_HandlePreNMIMsg(void) { + this->rumble.reset = TRUE; + padmgr_RumbleReset(); +} + +extern void padmgr_RequestPadData_NonLock(pad_t* pad, int flag) { + int i; + pad_t* padmgr_pad = this->pads; + pad_t* pad_p = pad; + int trigger; + + for (i = 0; i < this->num_controllers; i++) { + if (flag) { + /* Direct copy from padmgr */ + *pad_p = *padmgr_pad; + padmgr_pad->on.button = 0; + padmgr_pad->on.stick_x = 0; + padmgr_pad->on.stick_y = 0; + padmgr_pad->off.button = 0; + } else { + /* Only copy now from padmgr and update all other info from that */ + pad_p->last = pad_p->now; + pad_p->now = padmgr_pad->now; + trigger = pad_p->last.button ^ pad_p->now.button; + pad_p->on.button = trigger & pad_p->now.button; + pad_p->off.button = trigger & pad_p->last.button; + pad_correct_stick(pad_p); + pad_p->on.stick_x += (s8)(pad_p->now.stick_x - pad_p->last.stick_x); + pad_p->on.stick_y += (s8)(pad_p->now.stick_y - pad_p->last.stick_y); + } + + padmgr_pad++; + pad_p++; + } +} + +extern void padmgr_RequestPadData(pad_t* pad, int flag) { + padmgr_LockContData(); + padmgr_RequestPadData_NonLock(pad, flag); + padmgr_UnlockContData(); +} + +extern void padmgr_ClearPadData(pad_t* pad) { + int i; + + for (i = 0; i < this->num_controllers; i++) { + pad->last = pad->now; + pad->now.button = 0; + pad->now.stick_x = 0; + pad->now.stick_y = 0; + pad->on = pad->now; + pad->off = pad->now; + + pad++; + } +} + +static void padmgr_MainProc(void* arg) { + BOOL done = FALSE; + int flags; + + while (done == FALSE) { + VIWaitForRetrace(); + flags = PADMGR_FLAG_HANDLE_RETRACE; + + while (flags != 0) { + if ((flags & PADMGR_FLAG_DONE) != 0) { + flags &= ~PADMGR_FLAG_DONE; + done = TRUE; + } else if ((flags & PADMGR_FLAG_HANDLE_PRENMI) != 0) { + flags &= ~PADMGR_FLAG_HANDLE_PRENMI; + padmgr_HandlePreNMIMsg(); + } else if ((flags & PADMGR_FLAG_HANDLE_RETRACE) != 0) { + flags &= ~PADMGR_FLAG_HANDLE_RETRACE; + padmgr_HandleRetraceMsg(); + } + } + } +} + +extern void padmgr_Init(OSMessageQueue* mq) { + bzero(this, sizeof(padmgr)); + osCreateMesgQueue(&this->serial_mq, &this->_msg24, 1); + padmgr_UnlockSerialMesgQ(mq); + osCreateMesgQueue(&this->controller_lock_mq, &this->_msg28, 1); + padmgr_UnlockContData(); + osContInit(mq, &this->pad_pattern, this->pad_status); + this->num_controllers = MAXCONTROLLERS; + osContSetCh(this->num_controllers); +} + +extern void padmgr_Create(OSMessageQueue* serial_mq, OSId id, OSPri priority, void* stackend, size_t stack_size) { + padmgr_Init(serial_mq); + osCreateMesgQueue(&this->_msgQueue8C, this->_msgBuf2C, PADMSGBUFCNT); + osCreateThread2(&this->thread, id, &padmgr_MainProc, this, stackend, stack_size, priority); + osStartThread(&this->thread); +} + +extern int padmgr_isConnectedController(int idx) { + if (this->device_type[idx] == PADMGR_TYPE_CONTROLLER) { + return TRUE; + } + + return FALSE; +} diff --git a/src/zurumode.c b/src/zurumode.c index 3d39af0c..4d0b676c 100644 --- a/src/zurumode.c +++ b/src/zurumode.c @@ -9,10 +9,10 @@ static zuru_keycheck zuruKeyCheck; s32 zurumode_flag; static int zerucheck_init(zuru_keycheck* key_check) { - key_check->zurumode_enabled = FALSE; - key_check->state = ZURUMODE_STAGE_BEGIN_e; - key_check->progressing = ZURUMODE_RESET; - key_check->last_controller = 0; + key_check->zurumode_enabled = FALSE; + key_check->state = ZURUMODE_STAGE_BEGIN_e; + key_check->progressing = ZURUMODE_RESET; + key_check->last_controller = 0; } /** @@ -39,203 +39,197 @@ static int zerucheck_init(zuru_keycheck* key_check) { * returns int zurumodeEnabled */ static int zerucheck_key_check(zuru_keycheck* key_check, u32 controller) { - u32 controller_new; /* Buttons pressed on the current frame only */ - int state = key_check->state; /* Keycheck state */ - int progressing = key_check->progressing; /* Progressing through keycheck */ + u32 controller_new; /* Buttons pressed on the current frame only */ + int state = key_check->state; /* Keycheck state */ + int progressing = key_check->progressing; /* Progressing through keycheck */ - if (state != ZURUMODE_STAGE_FINAL_e) { - u16 controller_now = controller; - controller_new = - controller_now & (key_check->last_controller ^ controller_now); - key_check->last_controller = controller_now; + if (state != ZURUMODE_STAGE_FINAL_e) { + u16 controller_now = controller; + controller_new = controller_now & (key_check->last_controller ^ controller_now); + key_check->last_controller = controller_now; - if (controller_now == BUTTON_NONE && progressing == ZURUMODE_PROGRESSING) { - progressing = ZURUMODE_RESET; - } else if (controller_new != BUTTON_NONE) { - if (progressing == ZURUMODE_PROGRESSING) { - state = ZURUMODE_STAGE_BEGIN_e; - } + if (controller_now == BUTTON_NONE && progressing == ZURUMODE_PROGRESSING) { + progressing = ZURUMODE_RESET; + } else if (controller_new != BUTTON_NONE) { + if (progressing == ZURUMODE_PROGRESSING) { + state = ZURUMODE_STAGE_BEGIN_e; + } - switch (state) { - case ZURUMODE_STAGE_BEGIN_e: - /* L & R must be held first, then Z */ - if (controller_now == (BUTTON_R | BUTTON_L | BUTTON_Z) && - controller_new == BUTTON_Z) { - state = ZURUMODE_STAGE_1_e; - progressing = ZURUMODE_PROGRESSING; - } - break; + switch (state) { + case ZURUMODE_STAGE_BEGIN_e: + /* L & R must be held first, then Z */ + if (controller_now == (BUTTON_R | BUTTON_L | BUTTON_Z) && controller_new == BUTTON_Z) { + state = ZURUMODE_STAGE_1_e; + progressing = ZURUMODE_PROGRESSING; + } + break; - case ZURUMODE_STAGE_1_e: - if (controller_new == BUTTON_DUP) { - state = ZURUMODE_STAGE_2_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_1_e: + if (controller_new == BUTTON_DUP) { + state = ZURUMODE_STAGE_2_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_2_e: - if (controller_new == BUTTON_CDOWN) { - state = ZURUMODE_STAGE_3_e; - progressing = ZURUMODE_PROGRESSING; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_2_e: + if (controller_new == BUTTON_CDOWN) { + state = ZURUMODE_STAGE_3_e; + progressing = ZURUMODE_PROGRESSING; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_3_e: - if (controller_new == BUTTON_CUP) { - state = ZURUMODE_STAGE_4_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_3_e: + if (controller_new == BUTTON_CUP) { + state = ZURUMODE_STAGE_4_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_4_e: - if (controller_new == BUTTON_DDOWN) { - state = ZURUMODE_STAGE_5_e; - progressing = ZURUMODE_PROGRESSING; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_4_e: + if (controller_new == BUTTON_DDOWN) { + state = ZURUMODE_STAGE_5_e; + progressing = ZURUMODE_PROGRESSING; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_5_e: - if (controller_new == BUTTON_DLEFT) { - state = ZURUMODE_STAGE_6_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_5_e: + if (controller_new == BUTTON_DLEFT) { + state = ZURUMODE_STAGE_6_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_6_e: - if (controller_new == BUTTON_CLEFT) { - state = ZURUMODE_STAGE_7_e; - progressing = ZURUMODE_PROGRESSING; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_6_e: + if (controller_new == BUTTON_CLEFT) { + state = ZURUMODE_STAGE_7_e; + progressing = ZURUMODE_PROGRESSING; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_7_e: - if (controller_new == BUTTON_CRIGHT) { - state = ZURUMODE_STAGE_8_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_7_e: + if (controller_new == BUTTON_CRIGHT) { + state = ZURUMODE_STAGE_8_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_8_e: - if (controller_new == BUTTON_DRIGHT) { - state = ZURUMODE_STAGE_9_e; - progressing = ZURUMODE_PROGRESSING; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_8_e: + if (controller_new == BUTTON_DRIGHT) { + state = ZURUMODE_STAGE_9_e; + progressing = ZURUMODE_PROGRESSING; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_9_e: - if (controller_new == (BUTTON_B | BUTTON_A)) { - state = ZURUMODE_STAGE_10_e; - } else if (controller_new == BUTTON_A) { - state = ZURUMODE_STAGE_91_e; - } else if (controller_new == BUTTON_B) { - state = ZURUMODE_STAGE_92_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_9_e: + if (controller_new == (BUTTON_B | BUTTON_A)) { + state = ZURUMODE_STAGE_10_e; + } else if (controller_new == BUTTON_A) { + state = ZURUMODE_STAGE_91_e; + } else if (controller_new == BUTTON_B) { + state = ZURUMODE_STAGE_92_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_91_e: - if (controller_new == BUTTON_B) { - state = ZURUMODE_STAGE_10_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_91_e: + if (controller_new == BUTTON_B) { + state = ZURUMODE_STAGE_10_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_92_e: - if (controller_new == BUTTON_A) { - state = ZURUMODE_STAGE_10_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; + case ZURUMODE_STAGE_92_e: + if (controller_new == BUTTON_A) { + state = ZURUMODE_STAGE_10_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; - case ZURUMODE_STAGE_10_e: - if (controller_new == BUTTON_START) { - state = ZURUMODE_STAGE_FINAL_e; - } else { - state = ZURUMODE_STAGE_BEGIN_e; - } - break; - } + case ZURUMODE_STAGE_10_e: + if (controller_new == BUTTON_START) { + state = ZURUMODE_STAGE_FINAL_e; + } else { + state = ZURUMODE_STAGE_BEGIN_e; + } + break; + } + } } - } - if (state == ZURUMODE_STAGE_FINAL_e) { - /* Zurumode code has been correctly input */ - key_check->zurumode_enabled ^= TRUE; - key_check->state = ZURUMODE_STAGE_BEGIN_e; - key_check->progressing = ZURUMODE_RESET; - } else { - key_check->state = state; - key_check->progressing = progressing; - } + if (state == ZURUMODE_STAGE_FINAL_e) { + /* Zurumode code has been correctly input */ + key_check->zurumode_enabled ^= TRUE; + key_check->state = ZURUMODE_STAGE_BEGIN_e; + key_check->progressing = ZURUMODE_RESET; + } else { + key_check->state = state; + key_check->progressing = progressing; + } - return key_check->zurumode_enabled; + return key_check->zurumode_enabled; } static s32 zurumode_update() { - s32 flag_now; - s32 zurumode_now; + s32 flag_now; + s32 zurumode_now; - flag_now = zurumode_flag; - zurumode_flag = zurumode_now = (APPNMI_ZURUMODE_GET()) ? (APPNMI_ZURUMODE2_GET() ? 2 : 1) : 0; + flag_now = zurumode_flag; + zurumode_flag = zurumode_now = (APPNMI_ZURUMODE_GET()) ? (APPNMI_ZURUMODE2_GET() ? 2 : 1) : 0; - if (flag_now != zurumode_now) { - OSReport("zurumode_flag が %d から %d に変更されました\n", flag_now, - zurumode_now); - if (zurumode_flag != 0) { - if (APPNMI_TESTMODE_GET() || APPNMI_ZURUMODE_GET()) { - JC_JUTAssertion_changeDevice(3); - JC_JUTDbPrint_setVisible(JC_JUTDbPrint_getManager(), 1); - } - } else { - JC_JUTAssertion_changeDevice(2); - JC_JUTDbPrint_setVisible(JC_JUTDbPrint_getManager(), 0); + if (flag_now != zurumode_now) { + OSReport("zurumode_flag が %d から %d に変更されました\n", flag_now, zurumode_now); + if (zurumode_flag != 0) { + if (APPNMI_TESTMODE_GET() || APPNMI_ZURUMODE_GET()) { + JC_JUTAssertion_changeDevice(3); + JC_JUTDbPrint_setVisible(JC_JUTDbPrint_getManager(), 1); + } + } else { + JC_JUTAssertion_changeDevice(2); + JC_JUTDbPrint_setVisible(JC_JUTDbPrint_getManager(), 0); + } } - } - return zurumode_flag; + return zurumode_flag; } static void zurumode_callback(void* param) { - zerucheck_key_check(&zuruKeyCheck, (u32)(((padmgr*)param)->n64_pads[1].button)); - if (APPNMI_DEBUGMODE_GET() || - (APPNMI_TESTMODE_GET() && (padmgr_isConnectedController(1) != 0)) || - (zuruKeyCheck.zurumode_enabled != 0)) { - APPNMI_ZURUMODE_SET(); - } else { - APPNMI_ZURUMODE_CLR(); - } - if (APPNMI_DEBUGMODE_GET() && - (zuruKeyCheck.state != 0) && (zuruKeyCheck.zurumode_enabled == 0)) { - JW_JUTReport(60, 90, 1, "ZURU %d/%d", zuruKeyCheck.state, - zuruKeyCheck.progressing); - } + zerucheck_key_check(&zuruKeyCheck, (u32)(((padmgr*)param)->cur_pads[1].button)); + if (APPNMI_DEBUGMODE_GET() || (APPNMI_TESTMODE_GET() && (padmgr_isConnectedController(1) != 0)) || + (zuruKeyCheck.zurumode_enabled != 0)) { + APPNMI_ZURUMODE_SET(); + } else { + APPNMI_ZURUMODE_CLR(); + } + if (APPNMI_DEBUGMODE_GET() && (zuruKeyCheck.state != 0) && (zuruKeyCheck.zurumode_enabled == 0)) { + JW_JUTReport(60, 90, 1, "ZURU %d/%d", zuruKeyCheck.state, zuruKeyCheck.progressing); + } - zurumode_update(); + zurumode_update(); } extern void zurumode_init(void) { - zurumode_flag = 0; - zerucheck_init(&zuruKeyCheck); - zuruKeyCheck.zurumode_enabled = APPNMI_ZURUMODE_GET(); - padmgr_setClient2(zurumode_callback, &padmgr_class); - zurumode_update(); + zurumode_flag = 0; + zerucheck_init(&zuruKeyCheck); + zuruKeyCheck.zurumode_enabled = APPNMI_ZURUMODE_GET(); + padmgr_setClient2(zurumode_callback, &padmgr_class); + zurumode_update(); } extern void zurumode_cleanup(void) { - padmgr_removeClient2(zurumode_callback, &padmgr_class); - zurumode_flag = 0; + padmgr_removeClient2(zurumode_callback, &padmgr_class); + zurumode_flag = 0; }