void kstuffBatGetSerial(char* serial)
{
int r=0;
int k;
k = pspSdkSetK1(0);
if( use371nids == 0)
{
r = sceSyscon_driver_68EF0BEF(0x07);
serial[0] = (r / 0x100) & 0xFF;
serial[1] = r & 0xFF;
r = sceSyscon_driver_68EF0BEF(0x09);
serial[2] = (r / 0x100) & 0xFF;
serial[3] = r & 0xFF;
} else if ( use371nids == 1 ) {
r = sceSyscon_driver_B9C1B0AC(0x07);
serial[0] = (r / 0x100) & 0xFF;
serial[1] = r & 0xFF;
r = sceSyscon_driver_B9C1B0AC(0x09);
serial[2] = (r / 0x100) & 0xFF;
serial[3] = r & 0xFF;
} else if ( useDirectAccess == 1 ) {
r = batDirectReadEeprom(0x07);
serial[0] = (r / 0x100) & 0xFF;
serial[1] = r & 0xFF;
r = batDirectReadEeprom(0x09);
serial[2] = (r / 0x100) & 0xFF;
serial[3] = r & 0xFF;
}
pspSdkSetK1(k);
}
int kstuffBatSetSerial(char* serial)
{
int r=0;
int k;
int shi;
int slo;
shi = ((serial[0]&0xFF)*0x100)+(serial[1]&0xFF);
slo = ((serial[2]&0xFF)*0x100)+(serial[3]&0xFF);
k = pspSdkSetK1(0);
if( use371nids == 0)
{
r = sceSyscon_driver_1165C864(0x07, shi);
r = sceSyscon_driver_1165C864(0x09, slo);
} else if ( use371nids == 1 ) {
r = sceSyscon_driver_40CBBD46(0x07, shi);
r = sceSyscon_driver_40CBBD46(0x09, slo);
} else if ( useDirectAccess == 1 ) {
r = batDirectWriteEeprom(0x07, shi);
r = batDirectWriteEeprom(0x09, slo);
}
pspSdkSetK1(k);
return r;
}
int diva_poll(SceUID fd, SceInt64 *res) {
int ret;
u32 k1;
if(wait_fd >= 0 && fd == datafd) {
kprintf("polling for fd: %08X\n", wait_fd);
k1 = pspSdkSetK1(0);
ret = sceIoPollAsync(wait_fd, res);
if(ret <= 0) {
if(ret == 0) {
kprintf("Async read completed: %i bytes\n", (u32)*res);
*res = wait_size;
} else {
kprintf("polling error: %08X\n", ret);
}
sceIoClose(wait_fd);
wait_fd = -1;
} else {
kprintf("poll result: %08X\n", ret);
}
pspSdkSetK1(k1);
return ret;
}
return sceIoPollAsync(fd, res);
}
static SceOff myIoLseek(SceUID fd, SceOff offset, int whence)
{
SceOff ret;
u32 k1;
k1 = pspSdkSetK1(0);
if(g_keys_bin_found || g_is_custom_ps1) {
if (fd == RIF_MAGIC_FD) {
printk("%s: [FAKE]\n", __func__);
ret = 0;
} else if (fd == ACT_DAT_FD) {
printk("%s: [FAKE]\n", __func__);
ret = 0;
} else {
ret = sceIoLseek(fd, offset, whence);
}
} else {
ret = sceIoLseek(fd, offset, whence);
}
pspSdkSetK1(k1);
printk("%s: 0x%08X 0x%08X 0x%08X -> 0x%08X\n", __func__, (uint)fd, (uint)offset, (uint)whence, (int)ret);
return ret;
}
void KillME(volatile struct me_struct *mei, int devkitVersion)
{
unsigned int k1;
k1 = pspSdkSetK1(0);
if (mei == 0)
{
pspSdkSetK1(k1);
return;
}
mei->init = 0;
if (devkitVersion == 0x03070110){
sceSysregVmeResetEnable371();
sceSysregAvcResetEnable371();
sceSysregMeResetEnable371();
sceSysregMeBusClockDisable371();
}
else{
sceSysregVmeResetEnable();
sceSysregAvcResetEnable();
sceSysregMeResetEnable();
sceSysregMeBusClockDisable();
}
pspSdkSetK1(k1);
}
static void me_loop(volatile struct me_struct *mei)
{
unsigned int k1;
k1 = pspSdkSetK1(0);
while (mei->init) // ME runs this loop until killed
{
while (mei->start == 0); // wait for function
mei->start = 0;
if (mei->precache_len)
{
if (mei->precache_len < 0)
dcache_inv_all();
else
dcache_inv_range(mei->precache_addr, mei->precache_len);
}
mei->result = mei->func(mei->param); // run function
if (mei->postcache_len)
{
if (mei->postcache_len < 0)
dcache_wbinv_all();
else
dcache_wbinv_range(mei->postcache_addr, mei->postcache_len);
}
mei->done = 1;
}
pspSdkSetK1(k1);
while (1); // loop forever until ME reset
}
int kernel_loadExec(const char *file, int argc, char** argv)
{
u32 k1;
k1 = pspSdkSetK1(0);
// Store file name
strcpy(exefile, file);
// Concat argument strings
paramlength = 0;
// argv[0]
strcpy(parameters, file);
paramlength = strlen(file) + 1;
// Rest of the arguments
int i;
for (i = 0; i < argc; i++)
{
strcpy(¶meters[paramlength], argv[i]);
paramlength += (strlen(argv[i]) + 1);
}
SceUID thid = sceKernelCreateThread("launcher_thread", launcher_thread, 0x20, 0xFA0, 0, 0);
if (thid > -1)
thid = sceKernelStartThread(thid, 0, 0);
pspSdkSetK1(k1);
return 0;
}
static int _sceUsbStart(const char *driverName, int size, void *args)
{
int ret;
u32 k1;
k1 = pspSdkSetK1(0);
if (0 == strcmp(driverName, "USBStor_Driver")) {
if(conf.usbdevice > 0 && conf.usbdevice <= 5) {
if (g_usbdevice_modid < 0) {
g_usbdevice_modid = load_start_usbdevice();
}
if (g_usbdevice_modid >= 0) {
ret = pspUsbDeviceSetDevice(conf.usbdevice - 1, conf.flashprot, 0);
printk("%s: pspUsbDeviceSetDevice %d %d -> 0x%08X\n", __func__,
conf.usbdevice-1, conf.flashprot, ret);
}
}
}
pspSdkSetK1(k1);
ret = (*sceUsbStartOrig)(driverName, size, args);
return ret;
}
static int myIoClose(SceUID fd)
{
int ret;
u32 k1;
k1 = pspSdkSetK1(0);
if(g_keys_bin_found || g_is_custom_ps1) {
if (fd == RIF_MAGIC_FD) {
printk("%s: [FAKE]\n", __func__);
ret = 0;
} else if (fd == ACT_DAT_FD) {
printk("%s: [FAKE]\n", __func__);
ret = 0;
} else {
ret = sceIoClose(fd);
}
} else {
ret = sceIoClose(fd);
}
if(g_plain_doc_fd == fd && ret == 0) {
g_plain_doc_fd = -1;
}
pspSdkSetK1(k1);
printk("%s: 0x%08X -> 0x%08X\n", __func__, fd, ret);
return ret;
}
int mhp3_read(SceUID fd, void *data, SceSize size) {
u32 k1;
int res;
u32 cur;
SceOff pos;
SceSize offset;
if (fd == datafd) {
pos = sceIoLseek(fd, 0, PSP_SEEK_CUR);
cur = 0;
offset = data_start;
while (cur < patch_count) {
if (pos < patch_offset[cur] + patch_size[cur] && pos + size > patch_offset[cur]) {
k1 = pspSdkSetK1(0);
reopen_translation();
sceIoLseek(transfd, offset + (pos - patch_offset[cur]), PSP_SEEK_SET);
res = sceIoRead(transfd, data, size);
if (res != (int) size) {
kprintf("failed to read translation data\n");
}
pspSdkSetK1(k1);
sceIoLseek(fd, size, PSP_SEEK_CUR);
return res;
}
offset += patch_size[cur];
cur++;
}
} else {
res = read_install(fd, data, size);
return res;
}
res = sceIoRead(fd, data, size);
return res;
}
void setBrightness(int brightness){
u32 k1;
k1 = pspSdkSetK1(0);
sceDisplaySetBrightness(brightness, 0);
pspSdkSetK1(k1);
}
int decompress_data(u32 destSize, const u8 *src, u8 *dest)
{
u32 k1;
int ret;
k1 = pspSdkSetK1(0);
if (destSize < 0) {
reboot_vsh_with_error((u32)destSize);
pspSdkSetK1(k1);
return 0;
}
ret = sceKernelDeflateDecompress(dest, destSize, src, 0);
printk("%s: 0x%08X 0x%08X 0x%08X -> 0x%08X\n", __func__, (uint)destSize, (uint)src, (uint)dest, ret);
if (ret >= 0) {
ret = 0x92FF;
printk("%s: [FAKE] -> 0x%08X\n", __func__, ret);
}
pspSdkSetK1(k1);
return ret;
}
int load_quest_index() {
mib_table = NULL;
mib_elems = 0;
k1 = pspSdkSetK1(0);
model_go = sceKernelGetModel() == 4 ? 1 : 0;
strcpy(filename, "xxx:/mhp3rd/quest/mib_id.dat");
SET_DEVICENAME(filename, model_go);
kprintf("trying to open %s\n", filename);
SceUID fd = sceIoOpen(filename, PSP_O_RDONLY, 0777);
if(fd < 0) {
kprintf("Cannot find mib_id.dat\n");
pspSdkSetK1(k1);
return fd;
}
SceSize size = (SceSize)sceIoLseek(fd, 0, PSP_SEEK_END);
sceIoLseek(fd, 0, PSP_SEEK_SET);
index_id = sceKernelAllocPartitionMemory(PSP_MEMORY_PARTITION_KERNEL, "mhp3mib", PSP_SMEM_High, size, NULL);
if(index_id >= 0) {
mib_table = sceKernelGetBlockHeadAddr(index_id);
sceIoRead(fd, mib_table, size);
mib_elems = size / (sizeof(u32) * 2);
quest_number = mib_table + mib_elems;
kprintf("index size: %i bytes, entries: %i\n", size, index_elems);
} else {
kprintf("failed to allocate memory for table\n");
}
sceIoClose(fd);
pspSdkSetK1(k1);
return 0;
}
static int check_file_is_encrypted(int fd)
{
int ret;
u32 k1;
char p[8 + 64], *buf;
k1 = pspSdkSetK1(0);
buf = (char*)((((u32)p) & ~(64-1)) + 64);
ret = sceIoRead(fd, buf, 8);
pspSdkSetK1(k1);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
if (ret != 8)
return 0;
if (!memcmp(buf, g_drm_magic_1, sizeof(g_drm_magic_1))) {
return 1;
}
if (!memcmp(buf, g_drm_magic_2, sizeof(g_drm_magic_2))) {
return 1;
}
#if 0
printk("%s: buf:\n", __func__);
hexdump(buf, 8);
#endif
return 0;
}
int sctrlSEGetConfig(TNConfig *config)
{
int k1 = pspSdkSetK1(0);
memset(config, 0, sizeof(TNConfig));
/* Default settings */
strcpy(config->nickname, "CEF User");
config->exit_button_1 = 2; //PSP_CTRL_START
config->exit_hold_duration = 2;
config->button_assign = 1; //CROSS
config->show_pic1 = 1; //enabled
SceUID fd = sceIoOpen("ms0:/PSP/SYSTEM/CONFIG.TN", PSP_O_RDONLY, 0);
if(fd < 0)
{
pspSdkSetK1(k1);
return fd;
}
int read = sceIoRead(fd, config, sizeof(TNConfig));
sceIoClose(fd);
pspSdkSetK1(k1);
return read;
}
//OK
void zeroCtrlFreeUserBuffer(SceUID uid) {
if (uid >= 0) {
k1 = pspSdkSetK1(0);
sceKernelFreePartitionMemory(uid);
pspSdkSetK1(k1);
}
}
static inline void lock(void)
{
u32 k1;
k1 = pspSdkSetK1(0);
sceKernelWaitSema(g_nodrm_sema, 1, 0);
pspSdkSetK1(k1);
}
static inline void unlock(void)
{
u32 k1;
k1 = pspSdkSetK1(0);
sceKernelSignalSema(g_nodrm_sema, 1);
pspSdkSetK1(k1);
}
int InitME(volatile struct me_struct *mei, int devkitVersion)
{
unsigned int k1;
k1 = pspSdkSetK1(0);
if (mei == 0)
{
pspSdkSetK1(k1);
return -1;
}
// initialize the MediaEngine Instance
mei->start = 0;
mei->done = 1;
mei->func = 0;
mei->param = 0;
mei->result = 0;
mei->precache_len = 0;
mei->precache_addr = 0;
mei->postcache_len = 0;
mei->postcache_addr = 0;
mei->signals = 0;
mei->init = 1;
// start the MediaEngine
memcpy((void *)0xbfc00040, me_stub, (int)(me_stub_end - me_stub));
_sw((unsigned int)me_loop, 0xbfc00600); // k0
_sw((unsigned int)mei, 0xbfc00604); // a0
sceKernelDcacheWritebackAll();
if (devkitVersion < 0x03070110)
{
sceSysregMeResetEnable();
sceSysregMeBusClockEnable();
sceSysregMeResetDisable();
}
else
{
sceSysregMeResetEnable371();
sceSysregMeBusClockEnable371();
sceSysregMeResetDisable371();
}
//Find SceMeRpc and disable it(causes indefinate wait when handling events, like suspend)
PspSysEventHandler *handlers = sceKernelReferSysEventHandler();
while (handlers != NULL){
if (strcmp(handlers->name, "SceMeRpc") == 0){
handler = handlers;
sceKernelUnregisterSysEventHandler(handler);
break;
}
handlers = handlers->next;
}
pspSdkSetK1(k1);
return 0;
}
int getBrightness(){
int currentBrightness = 0;
u32 k1;
k1 = pspSdkSetK1(0);
sceDisplayGetBrightness(¤tBrightness, 0);
pspSdkSetK1(k1);
return currentBrightness;
}
//OK
void *zeroCtrlAllocUserBuffer(SceUID uid, int size) {
void *addr;
k1 = pspSdkSetK1(0);
uid = sceKernelAllocPartitionMemory(PSP_MEMORY_PARTITION_USER, "pathBuf",
PSP_SMEM_High, size, NULL);
addr = (uid >= 0) ? sceKernelGetBlockHeadAddr(uid) : NULL;
pspSdkSetK1(k1);
return addr;
}
int kernel_sceKernelUnregisterSysEventHandler(PspSysEventHandler *handler)
{
u32 k1;
k1 = pspSdkSetK1(0);
int result = sceKernelUnregisterSysEventHandler(handler);
pspSdkSetK1(k1);
return result;
}
unsigned int kernel_sctrlHENFindFunction(char* modname, char* libname, unsigned int nid)
{
u32 k1;
k1 = pspSdkSetK1(0);
int result = sctrlHENFindFunction(modname, libname, nid);
pspSdkSetK1(k1);
return result;
}
int displayDisable(void){
u32 k1 = pspSdkSetK1(0);
int ret;
if (sceKernelDevkitVersion() < 0x03070110)
ret = sceDisplayDisable();
else
ret = sceDisplayDisable371();
pspSdkSetK1(k1);
return ret;
}
int snw_save(SceUtilitySavedataParam *params) {
if (sceUtilitySavedataInitStart_func == NULL) {
u32 k1 = pspSdkSetK1(0);
sceUtilitySavedataInitStart_func = (void *)sctrlHENFindFunction("sceUtility_Driver", "sceUtility", 0x50C4CD57);
pspSdkSetK1(k1);
}
params->base.language = PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
return sceUtilitySavedataInitStart_func(params);
}
void ResetME(int devkitVersion){
unsigned int k1 = pspSdkSetK1(0);
int *meStarted;
int ret;
if (devkitVersion < 0x03070000){
meStarted = (int*)(mod->text_addr+0x00002C5C);//352
*meStarted = 0;
ret = sceMeBootStart(2);
}
else if (devkitVersion < 0x03080000){
meStarted = (int*)(mod->text_addr+0x00002BCC);//371
*meStarted = 0;
ret = sceMeBootStart371(2);
}
else if (devkitVersion < 0x03090500){
meStarted = (int*)(mod->text_addr+0x00002C2C);//380
*meStarted = 0;
ret = sceMeBootStart380(2);
}
else if (devkitVersion < 0x05000000){
// *(int*)0xUNKNOWN3 = 0;//390
ret = sceMeBootStart395(2);
}
else if (devkitVersion < 0x06000000){
meStarted = (int*)(mod->text_addr+0x00002B9C);//500,550
*meStarted = 0;
ret = sceMeBootStart500(2);
}
else if (devkitVersion < 0x06020000){
meStarted = (int*)(mod->text_addr+0x00002C5C);//600
*meStarted = 0;
ret = sceMeBootStart620(2);
}
else if (devkitVersion < 0x06030500){
meStarted = (int*)(mod->text_addr+0x00002C4C);//620
*meStarted = 0;
ret = sceMeBootStart620(2);
}
else if (devkitVersion < 0x06060000){
meStarted = (int*)(mod->text_addr+0x00002C4C);//635,638,639,660
*meStarted = 0;
ret = sceMeBootStart635(2);
}//0x06030910
else{
meStarted = (int*)(mod->text_addr+0x00002C4C);//660
*meStarted = 0;
ret = sceMeBootStart660(2);
}
if (handler){
sceKernelRegisterSysEventHandler(handler);
}
pspSdkSetK1(k1);
}
void kstuffGetMoboVersions(int* baryon, int* tachyon)
{
u32 by, ty;
int k;
k = pspSdkSetK1(0);
ty = sceSysreg_driver_E2A5D1EE();
sceSyscon_driver_7EC5A957(&by);
pspSdkSetK1(k);
(*baryon) = by;
(*tachyon) = ty;
}
void xrPlayerSetSpeed(int cpu, int bus)
{
unsigned int k = pspSdkSetK1(0);
static bool inited = false;
if (!inited) {
scePowerSetClockFrequency2 =
(void *) FindProc("scePower_Service", "scePower", 0x545A7F3C);
scePowerIsBatteryCharging =
(void *) FindProc("scePower_Service", "scePower", 0x1E490401);
scePower_driver_A09FC577 =
(void *) FindProc("scePower_Service", "scePower_driver",
0xA09FC577);
scePower_driver_191A3848 =
(void *) FindProc("scePower_Service", "scePower_driver",
0x191A3848);
inited = true;
}
if (scePowerSetClockFrequency2 == 0 || scePowerIsBatteryCharging == 0
|| scePower_driver_A09FC577 == 0 || scePower_driver_191A3848 == 0) {
inited = false;
return;
}
scePowerSetClockFrequency2(cpu, cpu, bus);
if (scePowerIsBatteryCharging() != 0) {
pspSdkSetK1(k);
return;
}
static int ps1 = 0;
if (ps1 == 0) {
scePower_driver_A09FC577(1);
ps1 = 1;
pspSdkSetK1(k);
return;
}
static int ps2 = 0;
if (ps2 == 0) {
ps1 = 0;
ps2 = 1;
pspSdkSetK1(k);
return;
}
scePower_driver_191A3848(0);
ps1 = 0;
ps2 = 0;
pspSdkSetK1(k);
}
int _sceMeAudio_67CD7972(void *buf, int size)
{
int ret;
u32 k1;
k1 = pspSdkSetK1(0);
ret = (*sceMeAudio_67CD7972)(buf, size);
pspSdkSetK1(k1);
printk("%s: 0x%08X -> 0x%08X\n", __func__, size, ret);
return ret;
}
int pspDveMgrCheckVideoOut()
{
int k1 = pspSdkSetK1(0);
int intr = sceKernelCpuSuspendIntr();
// Warning: nid changed between 3.60 and 3.71
int cable = sceHprm_driver_1528D408();
sceKernelCpuResumeIntr(intr);
pspSdkSetK1(k1);
return cable;
}
