Implement & link padmgr

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]

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

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

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;
 

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;
+}

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;
 }