diff --git a/ICON0.PNG b/ICON0.PNG new file mode 100644 index 0000000..49ad511 Binary files /dev/null and b/ICON0.PNG differ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..00ef16d --- /dev/null +++ b/Makefile @@ -0,0 +1,24 @@ +TARGET = EVEREST +OBJS = crt0.o main.o utils.o hardware_utils.o system_utils.o translate.o imports.o everest_kernel/everest_kernel.o kumdman/pspUmdMan_driver.o + +CFLAGS = -O2 -G0 -Wall -fshort-wchar -fno-pic -mno-check-zero-division +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) -c + +LDFLAGS = -mno-crt0 -nostdlib -nodefaultlibs + +STDLIBS = -lpsprtc -lvlfgui -lvlfgu -lvlfutils -lvlflibc -lpsppower -lpspkubridge +LIBS = $(STDLIBS) -lpspreg + +PSP_FW_VERSION = 271 + +EXTRA_TARGETS = EBOOT.PBP +PSP_EBOOT_TITLE = PSP EVEREST 2 +PSP_EBOOT_ICON = ICON0.PNG +PSP_EBOOT_PIC1 = PIC1.PNG + +BUILD_PRX = 1 +PSP_LARGE_MEMORY = 1 + +PSPSDK = $(shell psp-config --pspsdk-path) +include ./build.mak diff --git a/PIC1.png b/PIC1.png new file mode 100644 index 0000000..83760d9 Binary files /dev/null and b/PIC1.png differ diff --git a/PRXs/intraFont.prx b/PRXs/intraFont.prx new file mode 100644 index 0000000..2b5a94b Binary files /dev/null and b/PRXs/intraFont.prx differ diff --git a/PRXs/vlf.prx b/PRXs/vlf.prx new file mode 100644 index 0000000..1518de0 Binary files /dev/null and b/PRXs/vlf.prx differ diff --git a/PSPEverest25.jpg b/PSPEverest25.jpg new file mode 100644 index 0000000..b3fff9b Binary files /dev/null and b/PSPEverest25.jpg differ diff --git a/ReadMeEn.txt b/ReadMeEn.txt new file mode 100644 index 0000000..374eebc --- /dev/null +++ b/ReadMeEn.txt @@ -0,0 +1,53 @@ +(PSP Everest 2 Rev.5 - 2011, frostegater) + ==================================== + +(Description): + # The program in Sony style for showing any information about you PSP... + + - For change backgroung use 'R' and 'L' triggers. + - Not guaranted correct works 'Battery Information' location with piracy batteries. + +(Everest -> Everest 2 changes): + - Rewrite code. + - Added random color of background when start program. + - Added fade when change menu. + - Added detect PSP x010 (Mexico). + - Added exit in XMB about 'HOME'/'PS' button. + - Unlocked power switch. + - Added new firmwares support. + - Added PSPgo and PSP-E10xx support. + - Some visual fixes. + - Added switching backgrounds by triggers and fade when switching. + - Added interactivity of 'Battery Information' location. + - Added more information to 'Hardware Information'->'Model' option. + - Removed some not needed strings in 'System Information' and 'Hardware Information' locations. + - Added 'Complete' status to 'Battery Information' -> 'Charging' option. + - Added able to showing Russian text in 'System Information' -> 'Username' option. + - Fixed detecting not readed battery on battery flashables PSP's (All Fat and Slim TA-085v1). + - Added able to detecting TA-094. + - Added new algorythm for detecting motherboard and renamed some motherboards. + - Added Russian language (if Russian language selected in 'System Settings' in XMB). + - Added able to detecting differences of TA-088v1 and TA-088v2. + - Rev.2: fixed freezing in 'System Information' location. + - Rev.3: fixed showing incorrect 'Left Time' when using in PSP-E10xx. + - Rev.4: fixed bugs with 'ё'and 'р' characters in 'Username' option. + - Rev.5: removed some debug functions. Added 'ё' and 'Ё' symbol to ascii2unicode convert function. + Also, fixed bug with showing 'Left Time' if it more 1h 40min. + +(Thanks and credits to): + # My mother and father, jas0nuk, Yoti, raing3, Total_Noob, some1, m0skit0, TyRaNiD, ErikPshat, vit9696, rewind83. + +(Tested on): + - PSP-E1000 (TA-096) + - PSP-N1000 (TA-091) + - PSP-1000 (TA-081) + - PSP-2000 (TA-085v1) + - PSP-2000 (TA-088v1/v2) + - PSP-3000 (TA-090v2) + +(Source License): +- GPLv3 (for more information use gpl-v3.txt in 'src' directory) + +(Contacts): +- +- 'http://www.pspx.ru/forum/member.php?u=261437' \ No newline at end of file diff --git a/ReadMeRu.txt b/ReadMeRu.txt new file mode 100644 index 0000000..63d3ea1 --- /dev/null +++ b/ReadMeRu.txt @@ -0,0 +1,54 @@ +(PSP Everest 2 Rev.5 - 2011, frostegater) + ===================================== + +(Описание): + # Программа в стиле стандартной темы XMB для вывода обширной информации о вашей PSP... + + - Для изменения цветового плана фона используйте кнопки 'L' и 'R'. + - Не гарантирована корректная работа с нелицензионными аккумуляторами в меню 'Информация о батарее'. + +(Everest -> Everest 2 изменения): + - Полностью переписан код. + - Добавлен случайный фон при запуске программы. + - Добавлены плавные переходы. + - Исправлено определение PSP Мексиканского региона (x010). + - Добавлен выход или приостановка (в PSPgo) по кнопке 'HOME'/'PS'. + - Разблокирован рычажок включения/выключения PSP. + - Добавлена поддержка новых прошивок. + - Добавлена поддержка PSPgo и PSP-E10xx. + - Некоторые визуальные исправления. + - Добавлено переключение фона посредством кнопок 'R' и 'L'. + - Добавлена интерактивность в меню 'Информация о батарее'. + - Добавлено больше информации в 'Информация о железе'->'Модель' строчку. + - Удалены некоторые ненужные строки в 'Информация о системе' и 'Информация о железе' локациях. + - Добавлен статус 'Закончена' в строку 'Информация о батарее' -> 'Зарядка'. + - Добавлена поддержка русских символов в строке 'Информация о системе' -> 'Псевдоним'. + - Исправлено определение не пандорящихся аккумуляторов (для Fat и Slim TA-085v1). + - Добавлена возможность определения платы TA-094. + - Добавлен новый алгоритм для определения материнской платы. + - Добавлен русский язык (если он выставлен в XMB). + - Добавлена возможность выявления различий TA-088v1 и TA-088v2. + - Rev.2: исправлено зависание при многократном переходе в локацию 'Информация о системе'. + - Rev.3: исправлено некорректное отображение значения в опции 'Оставшееся время' в локации 'Информация о батарее' + при использовании на PSP-E10xx. + - Rev.4: исправлено отображение символов 'ё' и 'р' в опции 'Псевдоним'. + - Rev.5: добавлены символы 'ё' и 'Ё' в функцию перевода ascii в unicode. Также удалены некоторые дебаг функции и испралена ошибка + в графе 'Оставшееся время' если время больше 1ч 40мин. + +(Спасибо): + # Моей маме и папе, jas0nuk, Yoti, raing3, Total_Noob, some1, m0skit0, TyRaNiD, ErikPshat, vit9696, rewind83, D2GM, Flash_Zero. + +(Протестировано на): + - PSP-E1000 (TA-096) + - PSP-N1000 (TA-091) + - PSP-1000 (TA-081) + - PSP-2000 (TA-085v1) + - PSP-2000 (TA-088v1/v2) + - PSP-3000 (TA-090v2) + +(Лицензия исходного кода:) +- GPLv3 (для получения информации читайте gpl-v3.txt в папке 'src'. + +(Контакты автора): +- +- 'http://www.pspx.ru/forum/member.php?u=261437'. \ No newline at end of file diff --git a/backgrounds.bmp b/backgrounds.bmp new file mode 100644 index 0000000..f6a258e Binary files /dev/null and b/backgrounds.bmp differ diff --git a/build.mak b/build.mak new file mode 100644 index 0000000..24224c8 --- /dev/null +++ b/build.mak @@ -0,0 +1,190 @@ +# PSP Software Development Kit - http://www.pspdev.org +# ----------------------------------------------------------------------- +# Licensed under the BSD license, see LICENSE in PSPSDK root for details. +# +# build.mak - Base makefile for projects using PSPSDK. +# +# Copyright (c) 2005 Marcus R. Brown +# Copyright (c) 2005 James Forshaw +# Copyright (c) 2005 John Kelley +# +# $Id: build.mak 2333 2007-10-31 19:37:40Z tyranid $ + +# Note: The PSPSDK make variable must be defined before this file is included. +ifeq ($(PSPSDK),) +$(error $$(PSPSDK) is undefined. Use "PSPSDK := $$(shell psp-config --pspsdk-path)" in your Makefile) +endif + +CC = psp-gcc +CXX = psp-g++ +AS = psp-gcc +LD = psp-gcc +AR = psp-ar +RANLIB = psp-ranlib +STRIP = psp-strip +MKSFO = mksfo +PACK_PBP = pack-pbp +FIXUP = psp-fixup-imports + +# Add in PSPSDK includes and libraries. +INCDIR := $(INCDIR) . $(PSPSDK)/include +LIBDIR := $(LIBDIR) . $(PSPSDK)/lib + +CFLAGS := $(addprefix -I,$(INCDIR)) $(CFLAGS) +CXXFLAGS := $(CFLAGS) $(CXXFLAGS) +ASFLAGS := $(CFLAGS) $(ASFLAGS) + +ifeq ($(PSP_LARGE_MEMORY),1) +MKSFO = mksfoex -d MEMSIZE=1 +endif + +ifeq ($(PSP_FW_VERSION),) +PSP_FW_VERSION=150 +endif + +CFLAGS += -D_PSP_FW_VERSION=$(PSP_FW_VERSION) +CXXFLAGS += -D_PSP_FW_VERSION=$(PSP_FW_VERSION) + +ifeq ($(BUILD_PRX),1) +LDFLAGS := $(addprefix -L,$(LIBDIR)) -specs=$(PSPSDK)/lib/prxspecs -Wl,-q,-T$(PSPSDK)/lib/linkfile.prx $(LDFLAGS) +EXTRA_CLEAN += $(TARGET).elf +# Setup default exports if needed +ifdef PRX_EXPORTS +EXPORT_OBJ=$(patsubst %.exp,%.o,$(PRX_EXPORTS)) +EXTRA_CLEAN += $(EXPORT_OBJ) +else +EXPORT_OBJ=$(PSPSDK)/lib/prxexports.o +endif +else +LDFLAGS := $(addprefix -L,$(LIBDIR)) $(LDFLAGS) +endif + +# Library selection. By default we link with Newlib's libc. Allow the +# user to link with PSPSDK's libc if USE_PSPSDK_LIBC is set to 1. + +PSPSDK_LIBC_LIB = + +# Link with following default libraries. Other libraries should be specified in the $(LIBS) variable. +# TODO: This library list needs to be generated at configure time. +# +ifeq ($(USE_KERNEL_LIBS),1) +PSPSDK_LIBS = -lpspdebug -lpspdisplay_driver -lpspctrl_driver -lpspsdk +LIBS := $(LIBS) $(PSPSDK_LIBS) $(PSPSDK_LIBC_LIB) -lpspkernel +else +ifeq ($(USE_USER_LIBS),1) +PSPSDK_LIBS = -lpspdebug -lpspdisplay -lpspge -lpspctrl -lpspsdk +LIBS := $(LIBS) $(PSPSDK_LIBS) $(PSPSDK_LIBC_LIB) -lpspnet \ + -lpspnet_inet -lpspnet_apctl -lpspnet_resolver -lpsputility \ + -lpspuser +else +PSPSDK_LIBS = -lpspdisplay -lpspge -lpspctrl -lpspsdk +LIBS := $(LIBS) $(PSPSDK_LIBS) $(PSPSDK_LIBC_LIB) -lpspnet \ + -lpspnet_inet -lpspnet_apctl -lpspnet_resolver -lpsputility \ + -lpspuser -lpspkernel +endif +endif + +# Define the overridable parameters for EBOOT.PBP +ifndef PSP_EBOOT_TITLE +PSP_EBOOT_TITLE = $(TARGET) +endif + +ifndef PSP_EBOOT_SFO +PSP_EBOOT_SFO = PARAM.SFO +endif + +ifndef PSP_EBOOT_ICON +PSP_EBOOT_ICON = NULL +endif + +ifndef PSP_EBOOT_ICON1 +PSP_EBOOT_ICON1 = NULL +endif + +ifndef PSP_EBOOT_UNKPNG +PSP_EBOOT_UNKPNG = NULL +endif + +ifndef PSP_EBOOT_PIC1 +PSP_EBOOT_PIC1 = NULL +endif + +ifndef PSP_EBOOT_SND0 +PSP_EBOOT_SND0 = NULL +endif + +ifndef PSP_EBOOT_PSAR +PSP_EBOOT_PSAR = NULL +endif + +ifndef PSP_EBOOT +PSP_EBOOT = EBOOT.PBP +endif + +ifeq ($(BUILD_PRX),1) +ifneq ($(TARGET_LIB),) +$(error TARGET_LIB should not be defined when building a prx) +else +FINAL_TARGET = $(TARGET).prx +endif +else +ifneq ($(TARGET_LIB),) +FINAL_TARGET = $(TARGET_LIB) +else +FINAL_TARGET = $(TARGET).elf +endif +endif + +all: $(EXTRA_TARGETS) $(FINAL_TARGET) + +kxploit: $(TARGET).elf $(PSP_EBOOT_SFO) + mkdir -p "$(TARGET)" + $(STRIP) $(TARGET).elf -o $(TARGET)/$(PSP_EBOOT) + mkdir -p "$(TARGET)%" + $(PACK_PBP) "$(TARGET)%/$(PSP_EBOOT)" $(PSP_EBOOT_SFO) $(PSP_EBOOT_ICON) \ + $(PSP_EBOOT_ICON1) $(PSP_EBOOT_UNKPNG) $(PSP_EBOOT_PIC1) \ + $(PSP_EBOOT_SND0) NULL $(PSP_EBOOT_PSAR) + +SCEkxploit: $(TARGET).elf $(PSP_EBOOT_SFO) + mkdir -p "__SCE__$(TARGET)" + $(STRIP) $(TARGET).elf -o __SCE__$(TARGET)/$(PSP_EBOOT) + mkdir -p "%__SCE__$(TARGET)" + $(PACK_PBP) "%__SCE__$(TARGET)/$(PSP_EBOOT)" $(PSP_EBOOT_SFO) $(PSP_EBOOT_ICON) \ + $(PSP_EBOOT_ICON1) $(PSP_EBOOT_UNKPNG) $(PSP_EBOOT_PIC1) \ + $(PSP_EBOOT_SND0) NULL $(PSP_EBOOT_PSAR) + +$(TARGET).elf: $(OBJS) $(EXPORT_OBJ) + $(LINK.c) $^ $(LIBS) -o $@ + $(FIXUP) $@ + +$(TARGET_LIB): $(OBJS) + $(AR) cru $@ $(OBJS) + $(RANLIB) $@ + +$(PSP_EBOOT_SFO): + $(MKSFO) '$(PSP_EBOOT_TITLE)' $@ + +ifeq ($(BUILD_PRX),1) +$(PSP_EBOOT): $(TARGET).prx $(PSP_EBOOT_SFO) + $(PACK_PBP) $(PSP_EBOOT) $(PSP_EBOOT_SFO) $(PSP_EBOOT_ICON) \ + $(PSP_EBOOT_ICON1) $(PSP_EBOOT_UNKPNG) $(PSP_EBOOT_PIC1) \ + $(PSP_EBOOT_SND0) $(TARGET).prx $(PSP_EBOOT_PSAR) +else +$(PSP_EBOOT): $(TARGET).elf $(PSP_EBOOT_SFO) + $(STRIP) $(TARGET).elf -o $(TARGET)_strip.elf + $(PACK_PBP) $(PSP_EBOOT) $(PSP_EBOOT_SFO) $(PSP_EBOOT_ICON) \ + $(PSP_EBOOT_ICON1) $(PSP_EBOOT_UNKPNG) $(PSP_EBOOT_PIC1) \ + $(PSP_EBOOT_SND0) $(TARGET)_strip.elf $(PSP_EBOOT_PSAR) + -rm -f $(TARGET)_strip.elf +endif + +%.prx: %.elf + psp-prxgen $< $@ + +%.c: %.exp + psp-build-exports -b $< > $@ + +clean: + -rm -f $(FINAL_TARGET) $(EXTRA_CLEAN) $(OBJS) $(PSP_EBOOT_SFO) $(PSP_EBOOT) $(EXTRA_TARGETS) + +rebuild: clean all diff --git a/compile.bat b/compile.bat new file mode 100644 index 0000000..9efdbec --- /dev/null +++ b/compile.bat @@ -0,0 +1,26 @@ +PATH = c:/pspsdk_old/bin + +cd everest_kernel +make +psp-build-exports -s exports.exp +bin2c everest_kernel.prx ../everest_kernel_prx.h everest_kernel_prx +rm *.o *.elf *.prx + +cd ../kumdman +make +psp-build-exports -s exports.exp +bin2c kumdman.prx ../kumdman_prx.h kumdman_prx +rm *.o *.elf *.prx + +cd ../PRXs +bin2c intraFont.prx ../intraFont_prx.h intraFont_prx +bin2c vlf.prx ../vlf_prx.h vlf_prx + +cd .. +rm *.pbp +bin2c backgrounds.bmp backgrounds_bmp.h backgrounds_bmp +make +rm *.o *.prx *.elf *.sfo backgrounds_bmp.h everest_kernel_prx.h kumdman_prx.h intraFont_prx.h vlf_prx.h +rm everest_kernel/everest_kernel.S everest_kernel/everest_kernel.o kumdman/pspUmdMan_driver.S kumdman/pspUmdMan_driver.o + +pause diff --git a/crt0.c b/crt0.c new file mode 100644 index 0000000..f143dc1 --- /dev/null +++ b/crt0.c @@ -0,0 +1,99 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "main.h" +#include "everest_kernel_prx.h" +#include "kumdman_prx.h" +#include "intraFont_prx.h" +#include "vlf_prx.h" + +extern int app_main(int argc, char *argv[]); +int language; + +int SetupCallbacks(void) +{ + int CallbackThread(SceSize args, void *argp) + { + int exit_callback(int arg1, int arg2, void *common) + { + sceKernelExitGame(); + + return 0; + } + + int cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL); + sceKernelRegisterExitCallback(cbid); + sceKernelSleepThreadCB(); + + return 0; + } + + int thid = sceKernelCreateThread("PSP_EVEREST_UPDATE_THREAD", CallbackThread, 0x11, 0xFA0, 0, 0); + if(thid >= 0) + sceKernelStartThread(thid, 0, 0); + + return thid; +} + +void LoadStartModuleBuffer(char *path, char *buf, int size, SceSize args, void *argp) +{ + SceUID mod, out; + + sceIoRemove(path); + out = sceIoOpen(path, PSP_O_WRONLY | PSP_O_CREAT, 0777); + sceIoWrite(out, buf, size); + sceIoClose(out); + + mod = sceKernelLoadModule(path, 0, NULL); + mod = sceKernelStartModule(mod, args, argp, NULL, NULL); + sceIoRemove(path); +} + +int start_thread(SceSize args, void *argp) +{ + char *path = (char *)argp; + int last_trail = -1; + + int i; + for(i = 0; path[i]; i++) + if(path[i] == '/') + last_trail = i; + + if(last_trail >= 0) + path[last_trail] = 0; + + sceIoChdir(path); + path[last_trail] = '/'; + + if(psp_model != 4) + LoadStartModuleBuffer("kumdman.prx", (void *)kumdman_prx, size_kumdman_prx, args, argp); + + LoadStartModuleBuffer("everest_kernel.prx", (void *)everest_kernel_prx, size_everest_kernel_prx, args, argp); + LoadStartModuleBuffer("intraFont.prx", (void *)intraFont_prx, size_intraFont_prx, args, argp); + strcpy((void *)vlf_prx + 0x6D678, "flash0:/font/ltn0.pgf");//WARNING: Path for font not be more 23 characters! + LoadStartModuleBuffer("vlf.prx", (void *)vlf_prx, size_vlf_prx, args, argp); + + vlfGuiInit(-1, app_main); + + return sceKernelExitDeleteThread(0); +} + +int module_start(SceSize args, void *argp) +{ + SetupCallbacks(); + psp_model = kuKernelGetModel(); + sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &language); + + SceUID thid = sceKernelCreateThread("PSP_EVEREST_START_THREAD", start_thread, 0x10, 0x4000, 0, NULL); + if(thid < 0) + return thid; + + sceKernelStartThread(thid, args, argp); + + return 0; +} diff --git a/everest_kernel.h b/everest_kernel.h new file mode 100644 index 0000000..b1b6708 --- /dev/null +++ b/everest_kernel.h @@ -0,0 +1,21 @@ +#ifndef ___KPSPIDENT_H___ +#define ___KPSPIDENT_H___ + +u32 sceSysconGetBaryonVersion(u32 *baryon);// 0x7EC5A957 +u32 sceSysconGetPommelVersion(u32 *pommel);// 0xE7E87741 +u32 sceSysregGetTachyonVersion(void);// 0xE2A5D1EE +u64 sceSysregGetFuseId(void);// 0x4F46EEDE +u32 sceSysregGetFuseConfig(void);// 0x8F4F4E96 +u32 pspGetKirkVersion(void); +u32 pspGetSpockVersion(void); +u32 pspNandGetScramble(void); +int GetRegion(void); +char *GetInitialFW(void); +int pspNandGetPageSize(void); +int pspNandGetTotalBlocks(void); +int pspNandGetPagesPerBlock(void); +u8 *GetMACAddress(u8 *buf); +int ReadSerial(u16 *pdata); +int WriteSerial(u16* serial); + +#endif diff --git a/everest_kernel/Makefile b/everest_kernel/Makefile new file mode 100644 index 0000000..fb42df7 --- /dev/null +++ b/everest_kernel/Makefile @@ -0,0 +1,19 @@ +TARGET = everest_kernel +OBJS = main.o + +INCDIR = ../include +CFLAGS = -O2 -G0 -Wall -fno-pic +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) + +PSP_FW_VERSION = 271 + +BUILD_PRX = 1 +PRX_EXPORTS = exports.exp + +LDFLAGS = -mno-crt0 -nostartfiles + +LIBS = -lpspkernel -lpspident -lpspnand_driver -lpspwlan + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build.mak diff --git a/everest_kernel/exports.exp b/everest_kernel/exports.exp new file mode 100644 index 0000000..1d2fa40 --- /dev/null +++ b/everest_kernel/exports.exp @@ -0,0 +1,27 @@ +PSP_BEGIN_EXPORTS + + PSP_EXPORT_START(syslib, 0, 0x8000) + PSP_EXPORT_FUNC_HASH(module_start) + PSP_EXPORT_VAR_HASH(module_info) + PSP_EXPORT_END + + PSP_EXPORT_START(everest_kernel, 0, 0x4001) + PSP_EXPORT_FUNC_HASH(sceSysconGetBaryonVersion) + PSP_EXPORT_FUNC_HASH(sceSysconGetPommelVersion) + PSP_EXPORT_FUNC_HASH(sceSysregGetTachyonVersion) + PSP_EXPORT_FUNC_HASH(sceSysregGetFuseId) + PSP_EXPORT_FUNC_HASH(sceSysregGetFuseConfig) + PSP_EXPORT_FUNC_HASH(pspGetKirkVersion) + PSP_EXPORT_FUNC_HASH(pspGetSpockVersion) + PSP_EXPORT_FUNC_HASH(pspNandGetScramble) + PSP_EXPORT_FUNC_HASH(GetRegion) + PSP_EXPORT_FUNC_HASH(GetInitialFW) + PSP_EXPORT_FUNC_HASH(pspNandGetPageSize) + PSP_EXPORT_FUNC_HASH(pspNandGetPagesPerBlock) + PSP_EXPORT_FUNC_HASH(pspNandGetTotalBlocks) + PSP_EXPORT_FUNC_HASH(GetMACAddress) + PSP_EXPORT_FUNC_HASH(WriteSerial) + PSP_EXPORT_FUNC_HASH(ReadSerial) + PSP_EXPORT_END + +PSP_END_EXPORTS diff --git a/everest_kernel/main.c b/everest_kernel/main.c new file mode 100644 index 0000000..814c0dd --- /dev/null +++ b/everest_kernel/main.c @@ -0,0 +1,323 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +PSP_MODULE_INFO("EVEREST_KERNEL", 0x1006, 7, 4); +PSP_MAIN_THREAD_ATTR(0); + +u32 sceSyscon_driver_7EC5A957(u32 *baryon);// Baryon +u32 sceSyscon_driver_E7E87741(u32 *pommel);// Pommel +u32 sceSysreg_driver_E2A5D1EE(void);// Tachyon +u64 sceSysreg_driver_4F46EEDE(void);// FuseId +u32 sceSysreg_driver_8F4F4E96(void);// FuseCfg +int sceSysregKirkBusClockEnable(void);// Kirk +int sceSysregAtaBusClockEnable(void);// Spock + +u32 sceSyscon_readbat371(u8 addr); +u32 sceSysconCmdExec(void *param, int unk); + +u32 sceSysconGetBaryonVersion(u32 *baryon) +{ + int k1 = pspSdkSetK1(0); + + int err = sceSyscon_driver_7EC5A957(baryon); + pspSdkSetK1(k1); + + return err; +} + +u32 sceSysconGetPommelVersion(u32 *pommel) +{ + int k1 = pspSdkSetK1(0); + + int err = sceSyscon_driver_E7E87741(pommel); + pspSdkSetK1(k1); + + return err; +} + +u32 sceSysregGetTachyonVersion(void) +{ + int k1 = pspSdkSetK1(0); + + int err = sceSysreg_driver_E2A5D1EE(); + + pspSdkSetK1(k1); + + return err; +} + +u64 sceSysregGetFuseId(void) +{ + int k1 = pspSdkSetK1(0); + + u64 err = sceSysreg_driver_4F46EEDE(); + + pspSdkSetK1(k1); + + return err; +} + +u32 sceSysregGetFuseConfig(void) +{ + int k1 = pspSdkSetK1(0); + int err = sceSysreg_driver_8F4F4E96(); + pspSdkSetK1(k1); + return err; +} + +u32 pspGetKirkVersion(void) +{ + int k1 = pspSdkSetK1(0); + + sceSysregKirkBusClockEnable(); + sceKernelDelayThread(1000); + int err = *(u32 *)0xBDE00004; + + pspSdkSetK1(k1); + + return err; +} + +u32 pspGetSpockVersion(void) +{ + int k1 = pspSdkSetK1(0); + + sceSysregAtaBusClockEnable(); + sceKernelDelayThread(1000); + int err = *(u32 *)0xBDF00004; + pspSdkSetK1(k1); + + return err; +} + +u32 pspNandGetScramble(void) +{ + int k1 = pspSdkSetK1(0); + + u32 magic; + u32 buf[4]; + u32 sha[5]; + buf[0] = *(vu32 *)(0xBC100090); + buf[1] = *(vu32 *)(0xBC100094); + buf[2] = *(vu32 *)(0xBC100090) << 1; + buf[3] = 0xD41D8CD9; + sceKernelUtilsSha1Digest((u8 *)buf, sizeof(buf), (u8 *)sha); + magic = (sha[0] ^ sha[3]) + sha[2]; + pspSdkSetK1(k1); + + return magic; +} + +void pspIdStorageLookup(u16 key, u32 offset, void *buf, u32 len) +{ + int k1 = pspSdkSetK1(0); + + memset(buf, 0, len); + sceIdStorageLookup(key, offset, buf, len); + + pspSdkSetK1(k1); +} + +/* +0x03 - Japan +0x04 - America +0x05 - Europe +0x06 - Korea +0x07 - United Kingdom +0x08 - Mexico +0x09 - Australia +0x0A - Hong-Kong +0x0B - Taiwan +0x0C - Russia +0x0D - China +*/ + +int GetRegion(void) +{ + u8 region[1]; + pspIdStorageLookup(0x100, 0x3D, region, 1); + + if(region[0] == 0x03)//Japan + return 0; + else if(region[0] == 0x04)//America + return 1; + else if(region[0] == 0x09)//Australia + return 2; + else if(region[0] == 0x07)//United Kingdom + return 3; + else if(region[0] == 0x05)//Europe + return 4; + else if(region[0] == 0x06)//Korea + return 5; + else if(region[0] == 0x0A)//Hong-Kong + return 6; + else if(region[0] == 0x0B)//Taiwan + return 7; + else if(region[0] == 0x0C)//Russia + return 8; + else if(region[0] == 0x0D)//China + return 9; + else if(region[0] == 0x08)//Mexico + return 10; + else + return -1; +} + +char *GetInitialFW(char *buf) +{ + pspIdStorageLookup(0x51, 0, buf, 5); + if(buf[0] == 0) + sprintf(buf, "-"); + + return buf; +} + +int pspNandGetPageSize(void) +{ + int k1 = pspSdkSetK1(0); + + int ret = sceNandGetPageSize(); + + pspSdkSetK1(k1); + + return ret; +} + +int pspNandGetPagesPerBlock(void) +{ + int k1 = pspSdkSetK1(0); + + int ret = sceNandGetPagesPerBlock(); + + pspSdkSetK1(k1); + + return ret; +} + +int pspNandGetTotalBlocks(void) +{ + int k1 = pspSdkSetK1(0); + + int ret = sceNandGetTotalBlocks(); + + pspSdkSetK1(k1); + + return ret; +} + +u8 *GetMACAddress(u8 *buf) +{ + sceWlanGetEtherAddr(buf); + + return buf; +} + +u32 writeBat(u8 addr, u16 data) +{ + int k1 = pspSdkSetK1(0); + + int res; + u8 param[0x60]; + + if(addr > 0x7F) + return(0x80000102); + + param[0x0C] = 0x73; + param[0x0D] = 5; + param[0x0E] = addr; + param[0x0F] = data; + param[0x10] = data >> 8; + + res = sceSysconCmdExec(param, 0); + + if(res < 0) + return res; + + pspSdkSetK1(k1); + + return 0; +} + +int WriteSerial(u16* serial) +{ + int err = 0; + + err = writeBat(0x07, serial[0]); + if(!err) + err = writeBat(0x09, serial[1]); + + return err; +} + +u32 ReadEEPROM(u8 addr) +{ + u8 param[0x60]; + + if(addr > 0x7F) + return 0x80000102; + + param[0x0C] = 0x74; + param[0x0D] = 3; + param[0x0E] = addr; + + int res = sceSysconCmdExec(param, 0); + if(res < 0) + return res; + + return (param[0x21] << 8) | param[0x20]; +} + +int ReadSerial(u16* pdata) +{ + int err = 0; + u32 data; + + u32 k1 = pspSdkSetK1(0); + + int errCheck(u32 chdata) + { + if((chdata & 0x80250000) == 0x80250000) + return -1; + else if(chdata & 0xFFFF0000) + return(chdata & 0xFFFF0000) >> 16; + + return 0; + } + + data = ReadEEPROM(0x07); + err = errCheck(data); + + if(err >= 0) + { + pdata[0] = (data & 0xFFFF); + data = ReadEEPROM(0x09); + err = errCheck(data); + if(err >= 0) + pdata[1] = (data & 0xFFFF); + else + err = data; + } + else + err = data; + + pspSdkSetK1(k1); + + return err; +} + +int module_start(SceSize args, void *argp) +{ + return 0; +} + +int module_stop(void) +{ + return 0; +} diff --git a/gpl-v3.txt b/gpl-v3.txt new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/gpl-v3.txt @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/hardware_utils.c b/hardware_utils.c new file mode 100644 index 0000000..4d10eff --- /dev/null +++ b/hardware_utils.c @@ -0,0 +1,141 @@ +#include +#include +#include +#include + +#include "main.h" +#include "utils.h" +#include "everest_kernel.h" +#include "translate.h" +#include "kumdman.h" + +char macbuf[256]; + +int GetFirstSymbolOfModel() +{ + switch(psp_model + 1) + { + case 1: + case 5: + case 11: + return 1; + + case 2: + return 2; + + case 3: + case 4: + case 7: + case 9: + return 3; + + default: + break; + } + + return -1; +} + +char *GetRegionName() +{ + int region = GetRegion(); + if(region >= 0 && region < 11) + return trans->hardware.regname[region]; + + return "-"; +} + +#define UNKNOWN 0x00000000 + +typedef struct +{ + u32 tachyon; + u32 baryon; + u32 pommel; + char *mobo_name; +} Motherboard; + +Motherboard detmobo[] = +{ + /* PSP-100x */ + { 0x00140000, 0x00030600, 0x00000103, "TA-079v1" }, + { 0x00200000, 0x00030600, 0x00000103, "TA-079v2" }, + { 0x00200000, 0x00040600, 0x00000103, "TA-079v3" }, + { 0x00300000, 0x00040600, 0x00000103, "TA-081v1" }, + { 0x00300000, 0x00040600, 0x00000104, "TA-081v2" }, + { 0x00400000, 0x00114000, 0x00000112, "TA-082" }, + { 0x00400000, 0x00121000, 0x00000112, "TA-086" }, + + /* PSP-200x */ + { 0x00500000, 0x0022B200, 0x00000123, "TA-085v1" }, + { 0x00500000, 0x00234000, 0x00000123, "TA-085v2" }, + { 0x00500000, 0x00243000, 0x00000123, "TA-088v1" },// >----| If initial FW: 4.01, skipped TA-088v1... + { 0x00500000, 0x00243000, 0x00000123, "TA-088v2" },// <----| ...and detected TA-088v2. + { 0x00600000, 0x00243000, 0x00000123, "TA-088v3" }, + { 0x00500000, 0x00243000, 0x00000132, "TA-090v1" }, + + /* PSP-300x */ + { 0x00600000, 0x00263100, 0x00000132, "TA-090v2" }, + { 0x00600000, 0x00263100, 0x00000133, "TA-090v3" }, + { 0x00600000, 0x00285000, 0x00000133, "TA-092" }, + { 0x00810000, 0x002C4000, 0x00000141, "TA-093v1" }, + { 0x00810000, 0x002C4000, 0x00000143, "TA-093v2" }, + { 0x00810000, 0x002E4000, 0x00000154, "TA-095v1" }, + { 0x00820000, 0x002E4000, 0x00000154, "TA-095v2" }, + + /* PSP-N100x (PSPgo) */ + { 0x00720000, 0x00304000, 0x00000133, "TA-091" }, + { 0x00800000, 0x002A0000, UNKNOWN, "TA-094" }, + + /* PSP-E100x (PSP Essentials aka PSP Street) */ + { 0x00900000, 0x00403000, 0x00000154, "TA-096" }, + + /* DTP-T1000A */ + { 0x00100000, UNKNOWN, UNKNOWN, "Devkit" }, +}; + +char *GetMoBoName() +{ + char *ret_mobo = "-"; + + int i; + for(i = 0; i < sizeof(detmobo) / sizeof(Motherboard); i++) + if(detmobo[i].tachyon == tachyon && (detmobo[i].baryon == baryon || detmobo[i].baryon == UNKNOWN) && (detmobo[i].pommel == pommel || detmobo[i].pommel == UNKNOWN)) + { + /* TA-088v1(3.95) / TA-088v2 (4.01) */ + if(i == 9 /* TA-088v1 */ && !strncmp(GetInitialFW(), "4.01", 4)) + continue; + else if(i == 10 /* TA-088v2 */ && strncmp(GetInitialFW(), "3.95", 4)) + ret_mobo = "TA-088v1/v2"; + + ret_mobo = detmobo[i].mobo_name; + } + + return ret_mobo; +} + +char *GetUMDFWText() +{ + _sceUmdExecInquiryCmd(_sceUmdManGetUmdDrive(0), param, buf); + memset(outtxt, 0, sizeof(outtxt)); + memcpy(&ai, buf, sizeof(ATAPI_INQURIY)); + strncpy(outtxt, ai.sony_spec, 5); + + return outtxt; +} + +char *GetMacAddressText() +{ + u8 macaddr[512]; + GetMACAddress(macaddr); + sprintf(macbuf, "%02X:%02X:%02X:%02X:%02X:%02X", macaddr[0], macaddr[1], macaddr[2], macaddr[3], macaddr[4], macaddr[5]); + + return macbuf; +} + +char *GetModelName() +{ + char *models[] = { "PSP Fat", "PSP Slim", "PSP Brite", "PSP Brite", "PSPgo", "-", "PSP Brite", "-", "PSP Brite", "-", "PSP Street" }; + + return models[psp_model]; +} diff --git a/hardware_utils.h b/hardware_utils.h new file mode 100644 index 0000000..5c515b2 --- /dev/null +++ b/hardware_utils.h @@ -0,0 +1,11 @@ +#ifndef ___HARDWARE_UTILS_H___ +#define ___HARDWARE_UTILS_H___ + +int GetFirstSymbolOfModel(); +char *GetRegionName(); +char *GetMoBoName(); +char *GetUMDFWText(); +char *GetMacAddressText(); +char *GetModelName(); + +#endif diff --git a/imports.S b/imports.S new file mode 100644 index 0000000..840c35e --- /dev/null +++ b/imports.S @@ -0,0 +1,7 @@ + .set noreorder + +#include "pspstub.s" + + STUB_START "SystemCtrlForUser",0x40090000,0x00020005 + STUB_FUNC 0x1090A2E1,sctrlHENGetVersion + STUB_FUNC 0x5328B431,sctrlHENGetMinorVersion diff --git a/kumdman.h b/kumdman.h new file mode 100644 index 0000000..dcdb33a --- /dev/null +++ b/kumdman.h @@ -0,0 +1,25 @@ +#ifndef ___KUMDMAN_H___ +#define ___KUMDMAN_H___ + +static char outtxt[0x12]; +typedef struct +{ + unsigned char peripheral_device_type; + unsigned char removable; + unsigned char standard_ver; + unsigned char atapi_response; + unsigned int additional; + char vendor_id[8]; + char product_id[16]; + char product_rev[4]; + char sony_spec[0x14]; +}ATAPI_INQURIY; + +ATAPI_INQURIY ai; +u8 buf[0x38]; +u8 param[4] = { 0, 0, 0x38, 0 }; + +void *_sceUmdManGetUmdDrive(int driveNum); +int _sceUmdExecInquiryCmd(void *drive, u8 *param, u8 *buf); + +#endif diff --git a/kumdman/Makefile b/kumdman/Makefile new file mode 100644 index 0000000..1a912f1 --- /dev/null +++ b/kumdman/Makefile @@ -0,0 +1,21 @@ +TARGET = kumdman +OBJS = main.o sceUmdMan_driver.o exports.o + +INCDIR = +CFLAGS = -O2 -G0 -Wall +CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti +ASFLAGS = $(CFLAGS) -c + +BUILD_PRX = 1 +PRX_EXPORTS = exports.exp + +USE_KERNEL_LIBC = 1 +USE_KERNEL_LIBS = 1 + +LIBDIR = +LDFLAGS = +LIBS = + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build_prx.mak + diff --git a/kumdman/exports.exp b/kumdman/exports.exp new file mode 100644 index 0000000..2a972ec --- /dev/null +++ b/kumdman/exports.exp @@ -0,0 +1,13 @@ +PSP_BEGIN_EXPORTS + + PSP_EXPORT_START(syslib, 0, 0x8000) + PSP_EXPORT_FUNC_HASH(module_start) + PSP_EXPORT_VAR_HASH(module_info) + PSP_EXPORT_END + + PSP_EXPORT_START(pspUmdMan_driver, 0, 0x4001) + PSP_EXPORT_FUNC_HASH(_sceUmdExecInquiryCmd) + PSP_EXPORT_FUNC_HASH(_sceUmdManGetUmdDrive) + PSP_EXPORT_END + +PSP_END_EXPORTS \ No newline at end of file diff --git a/kumdman/main.c b/kumdman/main.c new file mode 100644 index 0000000..8dedbcf --- /dev/null +++ b/kumdman/main.c @@ -0,0 +1,38 @@ +#include +#include + +PSP_MODULE_INFO("pspUmdMan_Driver", 0x1000, 1, 0); +PSP_MAIN_THREAD_ATTR(0); + +int sceUmdManGetUmdDrive(int driveNum); +int sceUmdExecInquiryCmd(void *drive, u8 *param, u8 *buf); + +void *_sceUmdManGetUmdDrive(int driveNum) +{ + int k1 = pspSdkSetK1(0); + void *drive = (void *)sceUmdManGetUmdDrive(driveNum); + + pspSdkSetK1(k1); + + return drive; +} + +int _sceUmdExecInquiryCmd(void *drive, u8 *param, u8 *buf) +{ + int k1 = pspSdkSetK1(0); + int res = sceUmdExecInquiryCmd(drive, param, buf); + + pspSdkSetK1(k1); + + return(res); +} + +int module_start(SceSize args, void *argp) +{ + return 0; +} + +int module_stop() +{ + return 0; +} diff --git a/kumdman/sceUmdMan_driver.S b/kumdman/sceUmdMan_driver.S new file mode 100644 index 0000000..94d23fe --- /dev/null +++ b/kumdman/sceUmdMan_driver.S @@ -0,0 +1,75 @@ + .set noreorder + +#include "pspstub.s" + + STUB_START "sceUmdMan_driver",0x00010011,0x00450005 + STUB_FUNC 0xD27D050E,sceUmdManInit + STUB_FUNC 0x0D3EA203,sceUmdManTerm + STUB_FUNC 0x2C756C37,sceUmdMan_driver_2C756C37 + STUB_FUNC 0xCC80CFC6,sceUmdManActivate + STUB_FUNC 0x8CFED611,sceUmdManStart + STUB_FUNC 0xCAD31025,sceUmdManStop + STUB_FUNC 0xF6BE91FC,sceUmdMan_driver_F6BE91FC + STUB_FUNC 0x47E2B6D8,sceUmdManGetUmdDrive + STUB_FUNC 0xB2368381,sceUmdManCheckDeviceReady + STUB_FUNC 0xE779ECEF,sceUmdManGetInquiry + STUB_FUNC 0xCEA5C857,sceUmdMan_driver_CEA5C857 + STUB_FUNC 0x8634FFC7,sceUmdMan_driver_8634FFC7 + STUB_FUNC 0x39704B6E,sceUmdMan_driver_39704B6E + STUB_FUNC 0x63ACFD28,sceUmdMan_driver_63ACFD28 + STUB_FUNC 0x84410A8E,sceUmdMan_driver_84410A8E + STUB_FUNC 0xFCFEF5FE,sceUmdManValidateUMD + STUB_FUNC 0x1B1BF9FD,sceUmdExecRead10Cmd + STUB_FUNC 0x18DE1880,sceUmdExecPrefetch10Cmd + STUB_FUNC 0x3D44BABF,sceUmdExecReadUMDStructureCmd + STUB_FUNC 0xE3F448E0,sceUmdExecStartStopUnitCmd + STUB_FUNC 0x1B19A313,sceUmdExecInquiryCmd + STUB_FUNC 0x2CBE959B,sceUmdMan_driver_2CBE959B + STUB_FUNC 0x2A39569B,sceUmdExecModSenseCmd + STUB_FUNC 0xCEE55E3E,sceUmdExecModSelectCmd + STUB_FUNC 0xE5B7EDC5,sceUmdMan_driver_E5B7EDC5 + STUB_FUNC 0x65E1B97E,sceUmdExecGetEventStatusCmd + STUB_FUNC 0x5AA96415,sceUmdExecReadCapacityCmd + STUB_FUNC 0x250E6975,sceUmdExecSeekCmd + STUB_FUNC 0x2A08FE9A,sceUmdExecPreventAllowMediaCmd + STUB_FUNC 0x68577709,sceUmdExecAllocateFromReadCmd + STUB_FUNC 0xF819E17C,sceUmdExecReadMKICmd + STUB_FUNC 0x61C32A52,sceUmdExecSetAreaLimitCmd + STUB_FUNC 0x7094E3A7,sceUmdExecSetAccessLimitCmd + STUB_FUNC 0xD31DAD7E,sceUmdExecSetLockLengthCmd + STUB_FUNC 0x108B2322,sceUmdExecGetMediaInfoCmd + STUB_FUNC 0x98345381,sceUmdExecReportCacheCmd + STUB_FUNC 0xBF88476F,sceUmdMan_driver_BF88476F + STUB_FUNC 0x485D4925,sceUmdExecSetStreamingCmd + STUB_FUNC 0x73E49F8F,sceUmdExecClearCacheInfoCmd + STUB_FUNC 0x14D3381C,sceUmdExecTestCmd + STUB_FUNC 0x92F1CC33,sceUmdExecAdjustDataCmd + STUB_FUNC 0x61EB07A5,sceUmdExecGetErrorLogCmd + STUB_FUNC 0x77E6C03A,sceUmdMan_driver_77E6C03A + STUB_FUNC 0xA869CAB3,sceUmdMan_driver_A869CAB3 + STUB_FUNC 0xF65D819F,sceUmdManRegisterImposeCallBack + STUB_FUNC 0x2787078E,sceUmdManUnRegisterImposeCallback + STUB_FUNC 0x1F9AFFF4,sceUmdMan_driver_1F9AFFF4 + STUB_FUNC 0x8609D1E4,sceUmdManGetDiscInfo + STUB_FUNC 0xAAA4ED91,sceUmdManGetDiscInfo4VSH + STUB_FUNC 0xE192C10A,sceUmdManGetUmdDiscInfo + STUB_FUNC 0x42D28DD1,sceUmdMan_driver_42D28DD1 + STUB_FUNC 0x4FB913A3,sceUmdMan_driver_4FB913A3 + STUB_FUNC 0x7DF2A18D,sceUmdManSetAlarm + STUB_FUNC 0xB0A6DC55,sceUmdManCancelAlarm + STUB_FUNC 0xD1D4F296,sceUmdMan_driver_D1D4F296 + STUB_FUNC 0xBF8AED79,sceUmdManRegisterInsertEjectUMDCallBack + STUB_FUNC 0x4217E7F5,sceUmdManUnRegisterInsertEjectUMDCallBack + STUB_FUNC 0x4581E306,sceUmdManGetPowerStat + STUB_FUNC 0xCA68F200,sceUmdManChangePowerMode + STUB_FUNC 0xF4AFF62D,sceUmdMan_driver_F4AFF62D + STUB_FUNC 0x7C3D307C,sceUmdManSPKGetMKI + STUB_FUNC 0xB511F821,sceUmdMan_driver_B511F821 + STUB_FUNC 0x736AE133,sceUmdMan_driver_736AE133 + STUB_FUNC 0xBD13A488,sceUmdMan_driver_BD13A488 + STUB_FUNC 0x9814DCF3,sceUmdMan_driver_9814DCF3 + STUB_FUNC 0x3DCFAA71,sceUmdMan_driver_3DCFAA71 + STUB_FUNC 0x0DC8D26D,sceUmdMan_driver_0DC8D26D + STUB_FUNC 0x9F106F73,sceUmdMan_driver_9F106F73 + STUB_FUNC 0xB0A43DA7,sceUmdMan_driver_B0A43DA7 + STUB_END diff --git a/main.c b/main.c new file mode 100644 index 0000000..9f5510d --- /dev/null +++ b/main.c @@ -0,0 +1,537 @@ +//>>> PSP_EVEREST 2 +//Copyright(C) 2011, frostegater + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "main.h" +#include "vlf.h" +#include "utils.h" +#include "backgrounds_bmp.h" +#include "everest_kernel.h" +#include "hardware_utils.h" +#include "system_utils.h" + +#include "translate.h" + +PSP_MODULE_INFO("PSP_EVEREST", 0, 2, 0); +PSP_MAIN_THREAD_ATTR(0); + +#define NUM_DEL_ITEMS_MAIN 4 +#define NUM_DEL_ITEMS_HARDWARE 18 +#define NUM_DEL_ITEMS_BATTERY 12 +#define NUM_DEL_ITEMS_SYSTEM 7 + +#define EVE_ENTER_EN "Enter" +#define EVE_BACK_EN "Back" + +VlfText main_menu[NUM_DEL_ITEMS_MAIN], text_hardware[NUM_DEL_ITEMS_HARDWARE], text_battery[NUM_DEL_ITEMS_BATTERY], text_system[NUM_DEL_ITEMS_SYSTEM], title_text; +VlfPicture title_pic, pic_button_assign; + +int battery_break = 0, battery_fade_ctrl = 0, background_number, max_background_number, focus; +unsigned int button_assign; +char kirk[4], spock[4]; +u32 fusecfg, scramble; +u16 bserialdata[2], serialdata[2]; +u64 fuseid; + +void MainMenu(int select); +int ExitInMainMenuHardwareInfo(int enter); +int ExitInMainMenuBatteryInfo(int enter); +int ExitInMainMenuSystemInfo(int enter); +void HardwareInfo(); +void BatteryInfo(); +void SystemInfo(); + +void SetBottomDialog(int enter, int back, int (* handler)(int enter), int delete_bd); +void SetTitle(char *text); +void SetFade(); +void SetBackground(); + +int OnMainMenuScreenUp(void *param); +int OnMainMenuScreenDown(void *param); + +char *vertxt; + +int OnMainMenu(int enter) +{ + if(enter) + { + vlfGuiRemoveEventHandler(OnMainMenuScreenUp); + vlfGuiRemoveEventHandler(OnMainMenuScreenDown); + + int i; + for(i = 0; i < NUM_DEL_ITEMS_MAIN; i++) + vlfGuiRemoveText(main_menu[i]); + + switch(focus) + { + case 0: + HardwareInfo(); + break; + + case 1: + battery_break = 0; + BatteryInfo(); + break; + + case 2: + SystemInfo(); + break; + + case 3: + sceKernelExitGame(); + break; + } + } + + return VLF_EV_RET_NOTHING; +} + +int ExitInMainMenuHardwareInfo(int enter) +{ + if(!enter) + { + int i; + for(i = 0; i < NUM_DEL_ITEMS_HARDWARE; i++) + vlfGuiRemoveText(text_hardware[i]); + + if(!button_assign) + vlfGuiBottomDialog(-1, VLF_DI_ENTER, 1, 0, VLF_DEFAULT, NULL); + + vlfGuiCancelBottomDialog(); + + MainMenu(0); + } + + return VLF_EV_RET_NOTHING; +} + +int ExitInMainMenuBatteryInfo(int enter) +{ + if(!enter) + { + battery_break = 1; + if(!button_assign) + vlfGuiBottomDialog(-1, VLF_DI_ENTER, 1, 0, VLF_DEFAULT, NULL); + + vlfGuiCancelBottomDialog(); + MainMenu(1); + } + + return VLF_EV_RET_NOTHING; +} + +int ExitInMainMenuSystemInfo(int enter) +{ + if(!enter) + { + int i; + for(i = 0; i < NUM_DEL_ITEMS_SYSTEM; i++) + if(text_system[i] != NULL) + { + vlfGuiRemoveText(text_system[i]); + text_system[i] = NULL; + } + + if(pic_button_assign != NULL) + { + vlfGuiRemovePicture(pic_button_assign); + pic_button_assign = NULL; + } + + if(!button_assign) + vlfGuiBottomDialog(-1, VLF_DI_ENTER, 1, 0, VLF_DEFAULT, NULL); + + vlfGuiCancelBottomDialog(); + MainMenu(2); + } + + return VLF_EV_RET_NOTHING; +} + +void HardwareInfo() +{ + + SetTitle(trans->hardware_title); + + text_hardware[0] = pspEverestPrintf(10, 40, "Tachyon: 0x%08X", tachyon); + text_hardware[1] = pspEverestPrintf(10, 60, "Baryon: 0x%08X", baryon); + text_hardware[2] = pspEverestPrintf(10, 80, "Pommel: 0x%08X", pommel); + text_hardware[3] = pspEverestPrintf(10, 100, "FuseID: 0x%llX", fuseid); + text_hardware[4] = pspEverestPrintf(10, 120, "FuseCFG: 0x%08X", fusecfg); + text_hardware[5] = pspEverestPrintf(10, 140, "IDScramble: 0x%08X", scramble); + text_hardware[6] = pspEverestPrintf(10, 160, "Kirk: %c%c%c%c", kirk[3], kirk[2], kirk[1], kirk[0]); + text_hardware[7] = pspEverestPrintf(10, 180, psp_model == 4 ? "Spock: -" : "Spock: %c%c%c%c", spock[3], spock[2], spock[1], spock[0]); + text_hardware[8] = pspEverestPrintf(10, 200, GetFirstSymbolOfModel() != -1 ? trans->hardware.model : trans->hardware.no_model, psp_model == 4 ? "N" : psp_model == 10 ? "E" : "", GetFirstSymbolOfModel(), GetRegion() < 10 ? "0" : "", GetRegion(), GetModelName()); + + text_hardware[9] = pspEverestPrintf(250, 40, trans->hardware.mobo, GetMoBoName()); + text_hardware[10] = pspEverestPrintf(250, 60, trans->hardware.region, GetRegionName()); + text_hardware[11] = pspEverestPrintf(250, 80, trans->hardware.gen, psp_model < 10 ? "0" : "", psp_model + 1); + text_hardware[12] = pspEverestPrintf(250, 100, trans->hardware.eeprom, tachyon <= 0x00500000 && tachyon != 0x00100000 && baryon <= 0x0022B200 ? trans->yes : trans->no); + text_hardware[13] = pspEverestPrintf(250, 120, trans->hardware.pandora, tachyon <= 0x00500000 ? trans->yes : trans->no); + text_hardware[14] = pspEverestPrintf(250, 140, "MAC: %s", GetMacAddressText()); + text_hardware[15] = pspEverestPrintf(250, 160, trans->hardware.initialfw, GetInitialFW()); + text_hardware[16] = pspEverestPrintf(250, 180, trans->hardware.umdfw, psp_model == 4 ? "-" : GetUMDFWText()); + text_hardware[17] = pspEverestPrintf(250, 200, trans->hardware.nandsize, (pspNandGetPageSize() * pspNandGetPagesPerBlock() * pspNandGetTotalBlocks()) / 1024 / 1024); + + SetBottomDialog(0, 1, ExitInMainMenuHardwareInfo, 1); + SetFade(); +} + +void BatteryInfo() +{ + int swbt = 1, checkbt = 0; + + vlfGuiCancelCentralMenu(); + + if(button_assign) + vlfGuiBottomDialog(VLF_DI_BACK, -1, 1, 0, 0, NULL); + + vlfGuiCancelBottomDialog(); + + SetTitle(trans->battery_title); + + battery_fade_ctrl = 0; + + int update, first_cycle = 1; + for(update = 0;; update++) + { + if(update == 25 || battery_fade_ctrl) + { + update = 1; + first_cycle = (battery_fade_ctrl ? 1 : 0); + battery_fade_ctrl = 0; + } + + vlfGuiDrawFrame(); + + if(!first_cycle || update == 0) + { + int i; + for(i = 0; i < NUM_DEL_ITEMS_BATTERY; i++) + if(text_battery[i] != NULL) + { + vlfGuiRemoveText(text_battery[i]); + text_battery[i] = NULL; + } + + int battery_percent = scePowerGetBatteryLifePercent(); + int battery_life_time = scePowerGetBatteryLifeTime(); + + if(update != 0 && scePowerIsBatteryExist() && swbt && (psp_model == 0 || (tachyon <= 0x00500000 && baryon == 0x0022B200))) + { + ReadSerial(bserialdata); + + u16 wrbuffer[0x80]; + wrbuffer[0] = 0x5053; + if(bserialdata[0] != 0x5058) + wrbuffer[1] = 0x5058; + else + wrbuffer[1] = 0x4456; + + WriteSerial(wrbuffer); + + checkbt = 0; + ReadSerial(serialdata); + if(serialdata[0] == wrbuffer[0] && serialdata[1] == wrbuffer[1]) + { + checkbt = 1; + WriteSerial(bserialdata); + } + + swbt = 0; + } + + if(swbt == 0 && !scePowerIsBatteryExist()) + swbt = 1; + + text_battery[0] = pspEverestPrintf(15, 70, trans->battery.ex_power, psp_model == 4 ? "-" : scePowerIsPowerOnline() ? trans->yes : trans->no); + text_battery[1] = pspEverestPrintf(15, 90, trans->battery.batt_stat, scePowerIsBatteryExist() ? trans->battery.batt_stat_present : trans->battery.batt_stat_absent); + text_battery[2] = pspEverestPrintf(15, 110, trans->battery.charging, scePowerIsBatteryCharging() ? scePowerIsBatteryExist() ? battery_percent == 100 ? trans->battery.charging_cpl : trans->yes : trans->no : trans->no); + text_battery[3] = pspEverestPrintf(15, 130, battery_percent > 100 || battery_percent < 0 ? trans->battery.no_charge_lvl : trans->battery.charge_lvl, battery_percent); + text_battery[4] = pspEverestPrintf(15, 150, trans->battery.charge_stat, battery_percent >= 0 && battery_percent <= 20 ? trans->battery.charge_stat_low : battery_percent > 20 && battery_percent < 70 ? trans->battery.charge_stat_normal : battery_percent >= 70 && battery_percent <= 100 ? trans->battery.charge_stat_strong : "-"); + text_battery[5] = pspEverestPrintf(15, 170, battery_life_time < 0 || battery_life_time / 60 > 100 || (battery_life_time / 60 == 0 && battery_life_time - (battery_life_time / 60 * 60) == 0) ? trans->battery.no_left_time : trans->battery.left_time, battery_life_time / 60, battery_life_time - (battery_life_time / 60 * 60)); + + text_battery[6] = pspEverestPrintf(240, 70, scePowerGetBatteryVolt() <= 0 ? trans->battery.no_voltage : trans->battery.voltage, (float)scePowerGetBatteryVolt() / 1000.0); + text_battery[7] = pspEverestPrintf(240, 90, scePowerGetBatteryTemp() <= 0 ? trans->battery.no_temperature : trans->battery.temperature, scePowerGetBatteryTemp()); + text_battery[8] = pspEverestPrintf(240, 110, scePowerGetBatteryRemainCapacity() <= 0 ? trans->battery.no_remain_capacity : trans->battery.remain_capacity, scePowerGetBatteryRemainCapacity()); + text_battery[9] = pspEverestPrintf(240, 130, scePowerGetBatteryFullCapacity() <= 0 ? trans->battery.no_total_capacity : trans->battery.total_capacity, scePowerGetBatteryFullCapacity()); + text_battery[10] = pspEverestPrintf(240, 150, scePowerIsBatteryExist() && (psp_model == 0 || (tachyon == 0x00500000 && baryon == 0x0022B200)) && checkbt ? trans->battery.serial : trans->battery.no_serial, bserialdata[0], bserialdata[1]); + text_battery[11] = pspEverestPrintf(240, 170, trans->battery.mode, + checkbt && scePowerIsBatteryExist() && bserialdata[0] == 0xFFFF && bserialdata[1] == 0xFFFF && (psp_model == 0 || (tachyon <= 0x00500000 && baryon == 0x0022B200)) ? trans->battery.mode_service : + checkbt && scePowerIsBatteryExist() && bserialdata[0] == 0x0000 && bserialdata[1] == 0x0000 && (psp_model == 0 || (tachyon <= 0x00500000 && baryon == 0x0022B200)) ? trans->battery.mode_autoboot : + checkbt && scePowerIsBatteryExist() && (psp_model == 0 || (tachyon <= 0x00500000 && baryon == 0x0022B200)) ? trans->battery.mode_default : "-"); + } + + if(!update) + { + SetBottomDialog(0, 1, ExitInMainMenuBatteryInfo, 0); + SetFade(); + } + + if(battery_break) + { + int i; + for(i = 0; i < NUM_DEL_ITEMS_BATTERY; i++) + if(text_battery[i] != NULL) + { + vlfGuiRemoveText(text_battery[i]); + text_battery[i] = NULL; + } + + break; + } + + vlfGuiDrawFrame(); + } +} + +void SystemInfo() +{ + char username[32], password[5];; + memset(username, 0, sizeof(username)); + memset(password, 0, sizeof(password)); + + SetTitle(trans->system_title); + + text_system[0] = pspEverestPrintf(10, 45, trans->system.fw, GetFirmwareName()); + text_system[1] = pspEverestPrintf(10, 65, trans->system.button_assign); + + if(button_assign) + pic_button_assign = vlfGuiAddPictureResource("system_plugin_fg.rco", "tex_cross", 4, -2); + else + pic_button_assign = vlfGuiAddPictureResource("system_plugin_fg.rco", "tex_circle", 4, -2); + + vlfGuiSetPictureXY(pic_button_assign, 131, 68); + + + char unicode_username[26]; + utf82unicode((wchar_t *)unicode_username, (char *)GetRegistryValue("/CONFIG/SYSTEM", "owner_name", &username, sizeof(username), 0)); + + text_system[2] = pspEverestPrintf(237, 45, trans->system.username); + text_system[3] = vlfGuiAddTextW(language == PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN ? 337 : 327, 45, (u16 *)unicode_username); + text_system[4] = pspEverestPrintf(237, 65, trans->system.password, GetRegistryValue("/CONFIG/SYSTEM/LOCK", "password", &password, sizeof(password), 0)); + text_system[5] = pspEverestPrintf(10, 120, "version.txt:"); + + if(vertxt != NULL) + text_system[6] = vlfGuiAddTextF(10, 143, GetVersionTxt()); + else + text_system[6] = pspEverestPrintf(10, 143, trans->system.vertxterr); + + vlfGuiSetTextFontSize(text_system[6], 0.75f); + + SetBottomDialog(0, 1, ExitInMainMenuSystemInfo, 1); + SetFade(); +} + +void SetBottomDialog(int enter, int back, int (* handler)(int enter), int delete_bd) +{ + if(delete_bd) + { + if(button_assign) + vlfGuiBottomDialog(back ? VLF_DI_BACK : -1, enter ? VLF_DI_ENTER : -1, 1, 0, 0, NULL); + + vlfGuiCancelBottomDialog(); + } + + vlfGuiBottomDialog(back ? VLF_DI_BACK : -1, enter ? VLF_DI_ENTER : -1, 1, 0, VLF_DEFAULT, handler); +} + +void SetTitle(char *text) +{ + if(title_text != NULL) + vlfGuiRemoveText(title_text); + + if(title_pic != NULL) + vlfGuiRemovePicture(title_pic); + + title_text = pspEverestPrintf(30, 1, text); + title_pic = vlfGuiAddPictureResource("ps3scan_plugin.rco", "tex_infobar_icon", 4, -2); + + vlfGuiSetTitleBar(title_text, title_pic, 1, 0); +} + +void SetFade() +{ + if(pic_button_assign != NULL) + vlfGuiSetPictureFade(pic_button_assign, VLF_FADE_MODE_IN, VLF_FADE_SPEED_FAST, 0); + + vlfGuiSetRectangleFade(0, VLF_TITLEBAR_HEIGHT, 480, 272 - VLF_TITLEBAR_HEIGHT, VLF_FADE_MODE_IN, VLF_FADE_SPEED_FAST, 0, NULL, NULL, 0); +} + +int OnMainMenuScreenUp(void *param) +{ + switch(focus) + { + case 1: + focus = 0; + vlfGuiRemoveTextFocus(main_menu[1], 1); + vlfGuiSetTextFocus(main_menu[0]); + break; + + case 2: + focus = 1; + vlfGuiRemoveTextFocus(main_menu[2], 1); + vlfGuiSetTextFocus(main_menu[1]); + break; + + case 3: + focus = 2; + vlfGuiRemoveTextFocus(main_menu[3], 1); + vlfGuiSetTextFocus(main_menu[2]); + break; + + default: + focus = 3; + vlfGuiRemoveTextFocus(main_menu[0], 1); + vlfGuiSetTextFocus(main_menu[3]); + break; + } + + return VLF_EV_RET_NOTHING; +} + +int OnMainMenuScreenDown(void *param) +{ + switch(focus) + { + case 0: + focus = 1; + vlfGuiRemoveTextFocus(main_menu[0], 1); + vlfGuiSetTextFocus(main_menu[1]); + break; + + case 1: + focus = 2; + vlfGuiRemoveTextFocus(main_menu[1], 1); + vlfGuiSetTextFocus(main_menu[2]); + break; + + case 2: + focus = 3; + vlfGuiRemoveTextFocus(main_menu[2], 1); + vlfGuiSetTextFocus(main_menu[3]); + break; + + default: + focus = 0; + vlfGuiRemoveTextFocus(main_menu[3], 1); + vlfGuiSetTextFocus(main_menu[0]); + break; + } + + return VLF_EV_RET_NOTHING; +} + +void MainMenu(int select) +{ + SetTitle("PSP EVEREST 2"); + SetBottomDialog(1, 0, OnMainMenu, 0); + + focus = select; + + int main_x[4], main_y[4]; + if(language == PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN) + { + main_x[0] = 143; main_y[0] = 85; + main_x[1] = 141; main_y[1] = 107; + main_x[2] = 140; main_y[2] = 129; + main_x[3] = 207; main_y[3] = 151; + } + else + { + main_x[0] = 143; main_y[0] = 85; + main_x[1] = 151; main_y[1] = 107; + main_x[2] = 151; main_y[2] = 129; + main_x[3] = 212; main_y[3] = 151; + } + + main_menu[0] = pspEverestPrintf(main_x[0], main_y[0], trans->hardware_title); + main_menu[1] = pspEverestPrintf(main_x[1], main_y[1], trans->battery_title); + main_menu[2] = pspEverestPrintf(main_x[2], main_y[2], trans->system_title); + main_menu[3] = pspEverestPrintf(main_x[3], main_y[3], trans->exit); + + vlfGuiSetTextFocus(main_menu[select]); + vlfGuiAddEventHandler(PSP_CTRL_UP, 0, OnMainMenuScreenUp, NULL); + vlfGuiAddEventHandler(PSP_CTRL_DOWN, 0, OnMainMenuScreenDown, NULL); + + SetFade(); +} + +void SetBackground() +{ + if(background_number < 0) + background_number = max_background_number; + else if(background_number > max_background_number) + background_number = 0; + + vlfGuiSetBackgroundFileBuffer(backgrounds_bmp + background_number * 6176, 6176, 1); + SetFade(); +} + +int app_main(int argc, char *argv[]) +{ + sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &language); + SetupTranslate(); + + if(language == PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN) + vlfGuiSetLanguage(PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN); + else + vlfGuiSetLanguage(PSP_SYSTEMPARAM_LANGUAGE_ENGLISH); + + *(u32 *)kirk = pspGetKirkVersion(); + *(u32 *)spock = pspGetSpockVersion(); + tachyon = sceSysregGetTachyonVersion(); + fuseid = sceSysregGetFuseId(); + fusecfg = sceSysregGetFuseConfig(); + scramble = pspNandGetScramble(); + sceSysconGetBaryonVersion(&baryon); + sceSysconGetPommelVersion(&pommel); + devkit = sceKernelDevkitVersion(); + + GetRegistryValue("/CONFIG/SYSTEM/XMB", "button_assign", &button_assign, 4, 1); + + vertxt = GetVersionTxt(); + + vlfGuiSystemSetup(1, 1, 1); + + int OnBackgroundPlus(void *param) + { + background_number++; + battery_fade_ctrl = 1; + SetBackground(); + + return VLF_EV_RET_NOTHING; + } + + int OnBackgroundMinus(void *param) + { + background_number--; + battery_fade_ctrl = 1; + SetBackground(); + + return VLF_EV_RET_NOTHING; + } + + vlfGuiAddEventHandler(PSP_CTRL_RTRIGGER, -1, OnBackgroundPlus, NULL); + vlfGuiAddEventHandler(PSP_CTRL_LTRIGGER, -1, OnBackgroundMinus, NULL); + + max_background_number = size_backgrounds_bmp / 6176 - 1; + background_number = Random(0, max_background_number); + SetBackground(); + + MainMenu(0); + + while(1) + vlfGuiDrawFrame(); + + return 0; +} diff --git a/main.h b/main.h new file mode 100644 index 0000000..1660343 --- /dev/null +++ b/main.h @@ -0,0 +1,9 @@ +#ifndef ___MAIN_H___ +#define ___MAIN_H___ + +#include "vlf.h" + +int psp_model, devkit, language; +u32 tachyon, baryon, pommel; + +#endif diff --git a/system_utils.c b/system_utils.c new file mode 100644 index 0000000..97ee3d5 --- /dev/null +++ b/system_utils.c @@ -0,0 +1,128 @@ +#include +#include +#include +#include +#include + +#include "main.h" +#include "utils.h" +#include "translate.h" + +int sctrlHENGetMinorVersion(); +char get_firmware_buf[256], version_txt_buf[256]; + +char *GetFirmwareName() +{ + char *cfwname = ""; + int henid = sctrlHENGetVersion(); + + if(devkit == 0x05000010) + cfwname = "m33"; + else if(devkit == 0x05000210) + cfwname = "GEN"; + else if(devkit == 0x05000310) + { + if(henid != 0x8002013A) + cfwname = "GEN/MHU"; + else + cfwname = "GEN/MHU"; + } + else if(devkit == 0x05050010) + cfwname = "GEN"; + else if(devkit == 0x06020010) + { + if(sctrlHENGetMinorVersion() != 0x8002013A) + { + if(henid == 0x00001001) + cfwname = "PRO"; + else if(henid == 0x00001002) + cfwname = "PRO-B"; + else if(henid == 0x00001003) + cfwname = "PRO-C"; + } + else if(henid == 0x00001000) + cfwname = "TN-A"; + else if(henid == 0x00001001) + cfwname = "TN-B"; + else if(henid == 0x00001002) + cfwname = "TN-C"; + else if(henid == 0x00001003) + cfwname = "TN-D"; + else if(henid == 0x00001004) + cfwname = "TN-E"; + } + else if(devkit == 0x06030110) + cfwname = "PRO HEN"; + else if(devkit == 0x06030510) + { + if(sctrlHENGetMinorVersion() != 0x8002013A) + { + if(henid == 0x00001001) + cfwname = "PRO"; + else if(henid == 0x00001002) + cfwname = "PRO-B"; + else if(henid == 0x00001003) + cfwname = "PRO-C"; + } + else if(henid == 0x00001000) + cfwname = "Custom"; + } + else if(devkit == 0x06030610) + cfwname = "PRO HEN"; + else if(devkit == 0x06030710 && henid == 0x00001000) + cfwname = "ME"; + else if(devkit == 0x06030810 && henid == 0x00001000) + cfwname = "ME"; + else if(devkit == 0x06030910) + { + if(sctrlHENGetMinorVersion() != 0x8002013A) + { + if(henid == 0x00001001) + cfwname = "PRO"; + else if(henid == 0x00001002) + cfwname = "PRO-B"; + else if(henid == 0x00001003) + cfwname = "PRO-C"; + } + else if(henid == 0x00001000) + cfwname = "ME"; + else if(henid == 0x00002000) + cfwname = "TN-A"; + } + else if(devkit == 0x06060010) + { + if(sctrlHENGetMinorVersion() != 0x8002013A) + { + if(henid == 0x00001001) + cfwname = "PRO"; + else if(henid == 0x00001002) + cfwname = "PRO-B"; + else if(henid == 0x00001003) + cfwname = "PRO-C"; + } + else if(henid == 0x00001000) + cfwname = "ME"; + } + + char *devkit_chr = (char *)&devkit; + sprintf(get_firmware_buf, "%i.%i%i %s", devkit_chr[3], devkit_chr[2], devkit_chr[1], cfwname); + + return get_firmware_buf; +} + +char *GetVersionTxt() +{ + memset(version_txt_buf, 0, sizeof(version_txt_buf)); + SceUID fd = sceIoOpen("flash0:/vsh/etc/version.txt", PSP_O_RDONLY, 777); + if(fd >= 0) + sceIoRead(fd, version_txt_buf, 255); + else + { + sceIoClose(fd); + return NULL; + } + + sceIoClose(fd); + + return version_txt_buf; +} diff --git a/system_utils.h b/system_utils.h new file mode 100644 index 0000000..ffc1471 --- /dev/null +++ b/system_utils.h @@ -0,0 +1,7 @@ +#ifndef ___SYSTEM_UTILS_H___ +#define ___SYSTEM_UTILS_H___ + +char *GetFirmwareName(); +char *GetVersionTxt(); + +#endif diff --git a/translate.c b/translate.c new file mode 100644 index 0000000..e25df0d --- /dev/null +++ b/translate.c @@ -0,0 +1,168 @@ + +#include +#include "translate.h" +#include "main.h" + +/* English Translate*/ +EverestTranslate ENtrans = +{ + .yes = "Yes", + .no = "No", + .hardware_title = "Hardware Information", + .hardware = + { + .model = "Model: %s%d0%s%d (%s)", + .no_model = "Model: -", + .mobo = "Motherboard: %s", + .region = "Region: %s", + .gen = "Generation: %s%dg", + .eeprom = "EEPROM access: %s", + .pandora = "Pandora access: %s", + .initialfw = "Initial Firmware: %s", + .umdfw = "UMD™ Firmware: %s", + .nandsize = "NAND Size: %i MB", + .regname = + { + "Japan", + "America", + "Australia", + "United Kingdom", + "Europe", + "Korea", + "Hong-Kong", + "Taiwan", + "Russia", + "China", + "Mexico" + } + }, + .battery_title = "Battery Information", + .battery = + { + .ex_power = "External Power: %s", + .batt_stat = "Battery Status: %s", + .batt_stat_present = "Present", + .batt_stat_absent = "Absent", + .charging = "Charging: %s", + .charging_cpl = "Complete", + .no_charge_lvl = "Charge Level: -", + .charge_lvl = "Charge Level: %d%%", + .charge_stat = "Charge Status: %s", + .charge_stat_low = "Low", + .charge_stat_normal = "Normal", + .charge_stat_strong = "Strong", + .no_left_time = "Left Time: -", + .left_time = "Left Time: %d:%02d'", + .no_voltage = "Voltage: -", + .voltage = "Voltage: %0.2fV", + .no_temperature = "Temperature: -", + .temperature = "Temperature: %d'C", + .no_remain_capacity = "Remain Capacity: -", + .remain_capacity = "Remain Capacity: %i mAh", + .no_total_capacity = "Total Capacity: -", + .total_capacity = "Total Capacity: %i mAh", + .serial = "Serial: 0x%04X%04X", + .no_serial = "Serial: -", + .mode = "Mode: %s", + .mode_service = "Service", + .mode_autoboot = "Autoboot", + .mode_default = "Default" + }, + .system_title = "System Information", + .system = + { + .fw = "Firmware: %s", + .button_assign = "Button Assign:", + .username = "Username:", + .password = "Password: %s", + .vertxterr = "Error in open version.txt: 0x%08X." + }, + .exit = "Exit" +}; + +/* Russian Translate */ +EverestTranslate RUtrans = +{ + .yes = "Да", + .no = "Нет", + .hardware_title = "Информация о железе", + .hardware = + { + .model = "Модель: %s%d0%s%d (%s)", + .no_model = "Модель: -", + .mobo = "Мат. плата: %s", + .region = "Регион: %s", + .gen = "Модуль: %s%dg", + .eeprom = "Доступ к EEPROM: %s", + .pandora = "Работа пандоры: %s", + .initialfw = "Заводская прошивка: %s", + .umdfw = "Прошивка UMD™: %s", + .nandsize = "Размер NAND: %i МБ", + .regname = + { + "Япония", + "Америка", + "Австралия", + "Англия", + "Европа", + "Корея", + "Гонг-Конг", + "Тайвань", + "Россия", + "Китай", + "Мексика" + } + }, + .battery_title = "Информация о батарее", + .battery = + { + .ex_power = "Внешнее питание: %s", + .batt_stat = "Наличие батареи: %s", + .batt_stat_present = "Да", + .batt_stat_absent = "Нет", + .charging = "Зарядка: %s", + .charging_cpl = "Закончена", + .no_charge_lvl = "Уровень заряда: -", + .charge_lvl = "Уровень заряда: %d%%", + .charge_stat = "Статус заряда: %s", + .charge_stat_low = "Низкий", + .charge_stat_normal = "Средний", + .charge_stat_strong = "Высокий", + .no_left_time = "Оставшееся время: -", + .left_time = "Оставшееся время: %d:%02d'", + .no_voltage = "Напряжение: -", + .voltage = "Напряжение: %0.2fV", + .no_temperature = "Температура: -", + .temperature = "Температура: %d'C", + .no_remain_capacity = "Текущая ёмкость: -", + .remain_capacity = "Текущая ёмкость: %i мАч", + .no_total_capacity = "Общая ёмкость: -", + .total_capacity = "Общая ёмкость: %i мАч", + .serial = "Серийник: 0x%04X%04X", + .no_serial = "Серийник: -", + .mode = "Режим: %s", + .mode_service = "Сервисный", + .mode_autoboot = "Автозапуск", + .mode_default = "Обычный" + }, + .system_title = "Информация о системе", + .system = + { + .fw = "Прошивка: %s", + .button_assign = "Кнопка ввода:", + .username = "Псевдоним:", + .password = "Пароль: %s", + .vertxterr = "Ошибка при открытии version.txt: 0x%08X." + }, + .exit = "Выход" +}; + +EverestTranslate *trans; + +void SetupTranslate() +{ + if(language == PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN) + trans = &RUtrans; + else + trans = &ENtrans; +} diff --git a/translate.h b/translate.h new file mode 100644 index 0000000..a86b893 --- /dev/null +++ b/translate.h @@ -0,0 +1,80 @@ +#ifndef __TRANSLATE_H__ +#define __TRANSLATE_H__ + +struct HardwareInformation +{ + char *model; + char *no_model; + char *mobo; + char *region; + char *gen; + char *eeprom; + char *pandora; + char *initialfw; + char *umdfw; + char *nandsize; + char *regname[11]; +}; + +struct BatteryInformation +{ + char *ex_power; + char *batt_stat; + char *batt_stat_present; + char *batt_stat_absent; + char *charging; + char *charging_cpl; + char *no_charge_lvl; + char *charge_lvl; + char *charge_stat; + char *charge_stat_low; + char *charge_stat_normal; + char *charge_stat_strong; + char *no_left_time; + char *left_time; + char *no_voltage; + char *voltage; + char *no_temperature; + char *temperature; + char *no_remain_capacity; + char *remain_capacity; + char *no_total_capacity; + char *total_capacity; + char *serial; + char *no_serial; + char *mode; + char *mode_service; + char *mode_autoboot; + char *mode_default; +}; + +struct SystemInformation +{ + char *fw; + char *button_assign; + char *username; + char *password; + char *vertxterr; +}; + +typedef struct _EverestTranslate +{ + char *yes; + char *no; + + char *hardware_title; + struct HardwareInformation hardware; + + char *battery_title; + struct BatteryInformation battery; + + char *system_title; + struct SystemInformation system; + char *exit; +} EverestTranslate; + +extern EverestTranslate *trans; + +void SetupTranslate(); + +#endif diff --git a/utils.c b/utils.c new file mode 100644 index 0000000..f4b514b --- /dev/null +++ b/utils.c @@ -0,0 +1,135 @@ +#include +#include +#include +#include +#include +#include +#include +#include "main.h" + +int GetRegistryValue(const char *dir, const char *name, void *buf, int bufsize, int inttype) +{ + int ret = 0; + struct RegParam reg; + REGHANDLE h; + + memset(®, 0, sizeof(reg)); + reg.regtype = 1; + reg.namelen = strlen("/system"); + reg.unk2 = 1; + reg.unk3 = 1; + strcpy(reg.name, "/system"); + if(sceRegOpenRegistry(®, 2, &h) == 0) + { + REGHANDLE hd; + if(!sceRegOpenCategory(h, dir, 2, &hd)) + { + REGHANDLE hk; + unsigned int type, size; + + if(!sceRegGetKeyInfo(hd, name, &hk, &type, &size)) + if(!sceRegGetKeyValue(hd, hk, buf, bufsize)) + { + ret = inttype ? 1 : (int)buf; + sceRegFlushCategory(hd); + } + sceRegCloseCategory(hd); + } + sceRegFlushRegistry(h); + sceRegCloseRegistry(h); + } + + return ret; +} + +int Random(int min, int max) +{ + u64 tick; + SceKernelUtilsMt19937Context ctx; + sceRtcGetCurrentTick(&tick); + sceKernelUtilsMt19937Init(&ctx, (u32)tick); + + return min + (sceKernelUtilsMt19937UInt(&ctx) % max); +} + +int utf82unicode(wchar_t *dest, char *src) +{ + int i, x; + unsigned char *usrc = (unsigned char *)src; + + for(i = 0, x = 0; usrc[i];) + { + wchar_t ch; + + if((usrc[i] & 0xE0) == 0xE0) + { + ch = ((usrc[i] & 0x0F) << 12) | ((usrc[i + 1] & 0x3F) << 6) | (usrc[i + 2] & 0x3F); + i += 3; + } + else if((usrc[i] & 0xC0) == 0xC0) + { + ch = ((usrc[i] & 0x1F) << 6) | (usrc[i+1] & 0x3F); + i += 2; + } + else + { + ch = usrc[i]; + i += 1; + } + + dest[x++] = ch; + } + + dest[x++] = '\0'; + + return x; +} + +void ascii2unicode(char *unicode, const char *ascii) +{ + while(*ascii != '\0') + { + if((unsigned char)*ascii >= 0xC0) + { + *unicode++ = (unsigned char)*ascii - 0xB0; + *unicode++ = 0x04; + } + else if((unsigned char)*ascii == 0x99) + { + *unicode++ = 0x22; + *unicode++ = 0x21; + } + else if((unsigned char)*ascii == 0xB8) + { + *unicode++ = 0x51; + *unicode++ = 0x04; + } + else if((unsigned char)*ascii == 0xA8) + { + *unicode++ = 0x01; + *unicode++ = 0x04; + } + else + { + *unicode++ = *ascii; + *unicode++ = '\0'; + } + + ascii++; + } + + *unicode++ = '\0'; + *unicode++ = '\0'; +} + +VlfText pspEverestPrintf(int x, int y, const char *text, ...) +{ + char ascii[256], unicode[256]; + va_list list; + va_start(list, text); + vsprintf(ascii, text, list); + va_end(list); + ascii2unicode(unicode, ascii); + + return vlfGuiAddTextW(x, y, (u16 *)unicode); +} diff --git a/utils.h b/utils.h new file mode 100644 index 0000000..6abe2e6 --- /dev/null +++ b/utils.h @@ -0,0 +1,9 @@ +#ifndef ___UTILS_H___ +#define ___UTILS_H___ + +int GetRegistryValue(const char *dir, const char *name, void *buf, int bufsize, int inttype); +int Random(int min, int max); +int utf82unicode(wchar_t *dest, char *src); +VlfText pspEverestPrintf(int x, int y, const char *text, ...); + +#endif diff --git a/vlf.h b/vlf.h new file mode 100644 index 0000000..7bb6ddd --- /dev/null +++ b/vlf.h @@ -0,0 +1,2034 @@ +#ifndef __VLF_H__ +#define __VLF_H__ + +typedef struct _VlfText *VlfText; +typedef struct _VlfPicture *VlfPicture; +typedef struct _VlfShadowedPicture *VlfShadowedPicture; +typedef struct _VlfBatteryIcon *VlfBatteryIcon; +typedef struct _VlfSpin *VlfSpin; +typedef struct _VlfCheckBox *VlfCheckBox; +typedef struct _VlfProgressBar *VlfProgressBar; +typedef struct _VlfScrollBar *VlfScrollBar; +typedef struct _VlfInputBox *VlfInputBox; + + +#define VLF_DEFAULT -1 + +#define VLF_TITLEBAR_HEIGHT 22 + +#define VLF_ERROR_INVALID_INPUT (-1) +#define VLF_ERROR_INVALID_INPUT_DATA (-2) +#define VLF_ERROR_UNSUPPORTED_FORMAT (-3) +#define VLF_ERROR_OBJECT_OVERFLOW (-4) +#define VLF_ERROR_OBJECT_NOT_FOUND (-5) +#define VLF_ERROR_NO_MEMORY (-6) +#define VLF_ERROR_SYSTEM (-7) +#define VLF_ERROR_DUPLICATED (-8) + + +#define VLF_EV_RET_NOTHING 0 +#define VLF_EV_RET_REMOVE_EVENT 1 +#define VLF_EV_RET_REMOVE_OBJECTS 2 +#define VLF_EV_RET_REMOVE_HANDLERS 4 +#define VLF_EV_RET_REFRESH_ON_DELAY 8 +#define VLF_EV_RET_DELAY 0x80000000 /* Delay VLF_EV_RET_DELAY | (X << 16), 0 <= X <= 32767 milisecs */ +#define VLF_EV_RET_DELAY_FRAME (VLF_EV_RET_DELAY | 0x40000000) /* Delay VLF_EV_RET_DELAY_FRAME| (X << 16), 0 <= X <= 4095 */ + +/* Alignment */ + +enum VlfObjects +{ + VLF_TEXT = 0, + VLF_PIC = 1, + VLF_SHADOWED_PIC = 2, + VLF_PROGRESS_BAR = 3 +}; + +enum VlfTextAlignment +{ + VLF_ALIGNMENT_LEFT = 0, + VLF_ALIGNMENT_CENTER = 0x200, + VLF_ALIGNMENT_RIGHT = 0x400 +}; + +enum VlfButtonIcon +{ + VLF_ENTER = 0, + VLF_CANCEL = 1, + VLF_CROSS = 2, + VLF_CIRCLE = 3, + VLF_TRIANGLE = 4, + VLF_SQUARE = 5 +}; +/** Fade modes */ + +enum VlfFadeModesFlags +{ + VLF_FADE_MODE_IN = 1, + VLF_FADE_MODE_OUT = 2, + VLF_FADE_MODE_REPEAT = 4, +}; + +enum VlfFadeSpeed +{ + VLF_FADE_SPEED_STANDARD, + VLF_FADE_SPEED_FAST, + VLF_FADE_SPEED_VERY_FAST, + VLF_FADE_SPEED_SLOW, + VLF_FADE_SPEED_SUPER_FAST +}; + +enum VlfBatteryIconStatus +{ + VLF_BATTERY_ICON_HIGH, + VLF_BATTERY_ICON_MEDIUM, + VLF_BATTERY_ICON_LOW, + VLF_BATTERY_ICON_LOWEST +}; + +enum RCOType +{ + RCO_GRAPHIC, + RCO_OBJECT, + RCO_SOUND, + RCO_LABEL, + RCO_FILEPARAM, + RCO_ANIMPARAM +}; + +enum VLF_MDType +{ + VLF_MD_TYPE_ERROR, + VLF_MD_TYPE_NORMAL, +}; + +enum VLF_MD_Buttons +{ + VLF_MD_BUTTONS_NONE = 0, + VLF_MD_BUTTONS_YESNO = 0x10, +}; + +enum VLF_MD_InitalCursor +{ + VLF_MD_INITIAL_CURSOR_YES = 0, + VLF_MD_INITIAL_CURSOR_NO = 0x100, +}; + +enum VLF_MD_ButtonRes +{ + VLF_MD_NONE, + VLF_MD_YES, + VLF_MD_NO, + VLF_MD_BACK +}; + +enum VLF_DialogItem +{ + VLF_DI_ENTER, + VLF_DI_CANCEL, + VLF_DI_BACK, + VLF_DI_YES, + VLF_DI_NO, + VLF_DI_EDIT, +}; + +enum VLF_SpinState +{ + VLF_SPIN_STATE_NOT_FOCUS, // Spin control has not focus, buttons are not listened + VLF_SPIN_STATE_FOCUS, // Spin control text has focus but arrow is not shown, buttons are not listened + VLF_SPIN_STATE_ACTIVE, // Spin control has focus, and it is active (arrows are shown, up and down buttons are listened) +}; + +enum VLF_InputBoxType +{ + VLF_INPUTBOX_TYPE_NORMAL, + VLF_INPUTBOX_TYPE_PASSWORD +}; + +enum PspCtrlExtension +{ + PSP_CTRL_ENTER = 0x40000000, + PSP_CTRL_CANCEL = 0x80000000 +}; + +/** + * Inits VLF library + * + * @param heap_size - The heap size to be allocated. It can be negative. + * @param app_main - The program main application. +*/ +void vlfGuiInit(int heap_size, int (* app_main)(int argc, char *argv[])); + +/** + * Performs typical application initialization tasks (adding background, system model, and optionally battery icon and clock). + * + * @param battery - Inidicates if a battery icon should be added. + * @param clock - Indicates if a clock should be added. + * @param notuserwp - If user configuration is set to use a custom background and this param is 1, then the custom wallpaper won't be used. + * + * @returns 0 on success + * + * @Notes: If an user wallpaper is used, the background model ("waves") won't be added. + */ +int vlfGuiSystemSetup(int battery, int clock, int notuserwp); + +/** + * Gets language used by vlf application + * + * @returns - The language set to be used by current vlf application + * By default is initialized to user language. +*/ +int vlfGuiGetLanguage(); + +/** + * Sets language to be used by blf application + * + * @param lang - The language to be set. + * This only sets the language to be used by current vlf application, + * it doesn't overwrite user preferences in flash. + */ +void vlfGuiSetLanguage(int lang); + +/** + * Gets the button configuration used by vlf application (0 -> circle is enter, 1 -> cross is enter) + * + * @returns - The button configuration set to be used by current vlf application. + * By default is initialized with user preferences. +*/ +int vlfGuiGetButtonConfig(); + +/** + * Sets the button configuration to be used by current vlf application. + * + * @param config - The button configuration to be set (0 -> circle is enter, 1 -> cross is enter) + * This only sets the button configuration to be used by current vlf application, + * it doesn't overwrite user preferences in flash. +*/ +void vlfGuiSetButtonConfig(int config); + +/** + * Sets the directories where resources are located. + * + * @param dir - The directory that will be used to locate resources (max 256 chars including '\0') + * By default is initialized to flash0:/vsh/resource +*/ +void vlfGuiSetResourceDir(char *dir); + +/** + * Performs the draw of next frame +*/ +void vlfGuiDrawFrame(); + +/** + * Loads resources from a rco file + * + * @param rco - It can be one of following things: + * - path relative to the directory without extension (e.g. "system_plugin_bg") + * - path relative to the directory with extension (e.g. "system_plugin_bg.rco") + * - path to a file (e.g. "flash0:/vsh/resource/system_plugin_bg.rco", "ms0:/myresfile.rco") + * + * RCO param is evaluated in the order given above, so if a rco file exists in current directory with name + * "system_plugin_bg.rco", it would load the one of and not the one of current directory. (in such a case, use "./system_plugin_bg.rco") + * + * @param n - The number of resources to loads + * @param names (IN) - An array with the names of resources + * @param types (IN) - An array with the types of the resources (one of RCOType) + * @param datas (OUT) - A pointer to a variable that will receive an array of pointers to the content of each resource, + * or NULL if a specific resource has not been found. + * Pointers returned are allocated with malloc, and should be deallocated by the application. + * + * @param sizes (OUT) - It will receive the sizes of the resources + * @param pntable (OUT) - A pointer that will receive the string table. Pass NULL if no required. + * Returned pointer is allocated with malloc and should be deallocated by the application. + * + * @returns - the number of resources loaded, or < 0 if there is an error. + * + * @Example: Load battery icon pic and shadow + * + * char *names[2]; + * void *datas[2]; + * int types[2], sizes[2]; + * + * names[0] = "tex_battery"; + * names[1] = "tex_battery_shadow"; + * types[0] = types[1] = RCO_GRAPHIC; + * + * int res = vlfGuiLoadResources("system_plugin_fg", 2, names, types, datas, sizes, NULL); + * if (res != 2) // error or not all resources loaded + * { + * if (res > 0) + * { + * if (datas[0]) + * free(datas[0]); + * if (datas[1]) + * free(datas[1]); + * } + * } + * else + * { + * void *bat; + * vlfGuiAddShadowedPicture(&bat, datas[0], sizes[0], datas[1], sizes[1], 441, 4, 1, 1, 1); + * free(datas[0]); + * free(datas[1]); + * } + * +*/ +int vlfGuiLoadResources(char *rco, int n, char **names, int *types, void **datas, int *sizes, char **pntable); + +/** + * Caches a resource in RAM, so it doesn't have to be loaded from storage device anymore. + * + * @param rco - The resource. Same rules apply to this param + * + * @returns - < 0 on error. +*/ +int vlfGuiCacheResource(char *rco); + +/** + * Uncaches a resource previously cached. + * + * @param rco - The resource to be uncached. + * + * @returns - < 0 on error. +*/ +int vlfGuiUncacheResource(char *rco); + + +//int vlfGuiGetResourceSubParam(void *entry, int insize, char *ntable, char *name, void **data, int *size); + +/** + * Loads an unicode string from a resource. + * + * @param str - Buffer that receives the string + * @param rco - The resource file to load the label from. + * @param name - The name of the resource + * + * @returns - < 0 on error. +*/ +int vlfGuiLoadLabel(u16 *str, char *rco, char *name); + +/** + * Sets the background from 8888 texture data + * + * @param texture - The texture data in 8888 format + * @param width - The width of texture. Must be a power of 2. + * @param height - The height of texture. Must be multiple of 8. + * @param swizzled - Indicates if the texture is already in the psp GE fast texture format + * @param scale_x - The x scale to apply + * @param scale_y - The y scale to apply + * + * @returns 0 on success, or < 0 on error (params invalid) +*/ +int vlfGuiSetBackground(u32 *texture, int width, int height, int swizzled, float scale_x, float scale_y); + +/** + * Sets the background from a file buffer. + * Supported formats are currently: BMP, TIM, GIM and PNG, with a depth of 24 or 32 bits. + * + * @param data - The buffer with the file data + * @param size - The size of the data + * @param scale - Wether to scale the image. If it is 0, the image will be centered and filled by black. + * + * @returns - 0 on success, < 0 on error. +*/ +int vlfGuiSetBackgroundFileBuffer(void *data, int size, int scale); + +/** + * Sets the background from a file + * Supported formats are currently: BMP, TIM, GIM and PNG, with a depth of 24 or 32 bits. + * + * @param file - Path to the file. + * @param scale - Wether to scale the image. If it is 0, the image will be centered and filled by black. + * + * @returns - 0 on success, < 0 on error. +*/ +int vlfGuiSetBackgroundFile(char *file, int scale); + +/** + * Sets one of system backgrounds based on the index. + * + * @param index - The index of the background, valid values are 1-27 + * (note that 13-27 is only available on slim and will return an error on old psp) + * + * @returns 0 on success, < 0 on error +*/ +int vlfGuiSetBackgroundIndex(int index); + +/** + * Sets one of system backgrounds based on the current date + * + * @returns 0 on success, < 0 on error +*/ +int vlfGuiSetBackgroundDate(); + +/** + * Sets a background of a single color + * + * @param color - The color in XXBBGGRR format (XX is ignored). + * + * @returns - this functions always succeeds returning 0 +*/ +int vlfGuiSetBackgroundPlane(u32 color); + +/** + * Sets the background according to the system configuration + * + * @returns - 0 on success, < 0 on error. +*/ +int vlfGuiSetBackgroundSystem(int notuserwp); + +/** + * Sets the system color, used in titlebars or menus + * + * @param index - the index of the color, 1-27 +*/ +void vlfGuiSetSystemColor(int index); + +/** + * Sets the background model from a buffer. + * + * @param data - The buffer with the model in GMO format + * @param size - The size of the model + * + * @returns - 0 on success, < 0 on error. +*/ +int vlfGuiSetModel(void *data, int size); + +/** + * Sets the background model from a file. + * + * @param file - The file with the model in GMO format + * + * @returns - 0 on success, < 0 on error. +*/ +int vlfGuiSetModelFile(char *file); + +/** + * Sets the background model from a resource. + * + * @param rco - The path to the RCO file + * @param name - The name of the resource + * + * @returns - 0 on success, < 0 on error. +*/ +int vlfGuiSetModelResource(char *rco, char *name); + +/** + * Sets the background model of the system, and applies the proper world matrix to it. + * + * @returns 0 on success, < 0 on error. +*/ +int vlfGuiSetModelSystem(); + +/** + * Sets the world matrix for the model. (by default, the world matrix is the identity + * after a model has been loaded, except when calling vlfGuiSetModelSystem). + * + * @param matrix - The matrix to set. + * + * @Example: Load waves (this sample assumes the default scale of 8.5) + * + * int res = vlfGuiSetModelResource("system_plugin_bg", "mdl_bg"); + * if (res < 0) process_error; + * + * ScePspFMatrix4 matrix; + * ScePspFVector3 scale; + * + * scale.x = scale.y = scale.z = 8.5f; + * gumLoadIdentity(&matrix); + * gumScale(&matrix, &scale); + * vlfGuiSetModelWorldMatrix(&matrix); +*/ +void vlfGuiSetModelWorldMatrix(ScePspFMatrix4 *matrix); + +/** + * Gets the world matrix of the model + * + * @returns a pointer to the model world matrix +*/ +ScePspFMatrix4 *vlfGuiGetModelWorldMatrix(); + +/** + * Sets the model speed + * + * @param speed - The speed, default model speed is 1.0f/60.0f +*/ +void vlfGuiSetModelSpeed(float speed); + +/** + * Sets a title bar with the current system color. + * + * @param text - Text of the title bar. Pass NULL if no required. + * @param pic - Picture of the title bar. Pass NULL if no required. + * @param visible - If the tile bar will be visible + * @param hideobj - If 1, it will hide objects that were current added within the area of the title bar. + */ +void vlfGuiSetTitleBar(VlfText text, VlfPicture pic, int visible, int hideobj); + +/** + * Sets a title bar with the desired color. + * + * @param text - Text of the title bar. Pass NULL if no required. + * @param pic - Picture of the title bar. Pass NULL if no required. + * @param visible - If the tile bar will be visible + * @param hideobj - If 1, it will hide objects that were current added within the area of the title bar. + * @param color - The color of the title bar. +*/ +void vlfGuiSetTitleBarEx(VlfText text, VlfPicture pic, int visible, int hideobj, u32 color); + +/** + * Sets the tile bar visibility. +*/ +void vlfGuiSetTitleBarVisibility(int visible); + +/** + * Adds a new text item from an ascii string. + * + * @param x - x position + * @param y - y position + * @param string - ascii string with the desired text + * + * @returns a VlfText item on success, NULL on error. +*/ +VlfText vlfGuiAddText(int x, int y, char *string); + +/** + * Adds a new text item from an unicode string. + * + * @param x - x position + * @param y - y position + * @param string - unicode string with the desired text + * + * @returns a VlfText item on success, NULL on error. +*/ +VlfText vlfGuiAddTextW(int x, int y, u16 *string); + +/** + * Adds a new text item from a string with format + * + * @param x - x position + * @param y - y position + * @param fmt - string with format + * + * @returns a VlfText item on success, NULL on error. +*/ +VlfText vlfGuiAddTextF(int x, int y, char *fmt, ...); + +/** + * Adds a new text item from a resource label + * + * @param rco - The resource file to load the label from. + * @param name - The name of the resource. + * @param x - x position + * @param y - y position + * + * @returns a VlfText item on success, NULL on error. +*/ +VlfText vlfGuiAddTextResource(char *rco, char *name, int x, int y); + +/** + * Removes a text item. + * + * @param text - The text item to remove + * + * @returns - < 0 on error. +*/ +int vlfGuiRemoveText(VlfText text); + +/** + * Sets the text of a VlfText item from an ascii string. + * + * @param text - The text item + * @param string - The ascii string to set. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetText(VlfText text, char *string); + +/** + * Sets the text of a VlfText item from an unicode string. + * + * @param text - The text item + * @param string - The unicode string to set. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetTextW(VlfText text, u16 *string); + +/** + * Sets the text of a VlfText item from a string with format. + * + * @param text - The text item + * @param fmt - The string with format. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetTextF(VlfText text, char *fmt, ...); + +/** + * Sets the text of a VlfText item from a resource label. + * + * @param text - The text item + * @param rco - The resource file to load the label from. + * @param name - The name of the resource. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetTextResource(VlfText text, char *rco, char *name); + +/** + * Sets focus on a VlfText item. + * + * @param text - The text item to set the focus. + * + * @returns - < 0 on error. + * + * @Note: this function should only be used with a text with a single line, and + * with default font size. +*/ +int vlfGuiSetTextFocus(VlfText text); + +/** + * Removes focus on a VlfText item previously focused. + * + * @param text - The text item to remove focus. + * + * @returns - < 0 on error. +*/ +int vlfGuiRemoveTextFocus(VlfText text, int keepres); + +/** + * Sets the visibility of a VlfText item. + * + * @param text - The text item. + * @param visible - boolean for the visibility. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetTextVisibility(VlfText text, int visible); + +/** + * Makes a VlfText item to blink. + * + * @param text - The text item to set blinking. + * @param nshow - The number of frames the item will be shown. + * @param nhide - The number of frames the item wil be hidden. + * + * @returns - < 0 on error + * + * @Notes: To remove blinking, pass both params to 0. +*/ +int vlfGuiSetTextBlinking(VlfText text, u32 nshow, u32 nhide); + +/** + * Makes a VlfText item to fade. + * + * @param text - The text item to fade. + * @param mode - Whatever OR combination of VlfFadeModesFlags + * @param speed - The fade speed, one of VlfFadeSpeed + * @param direction_out - If both, VLF_FADE_MODE_IN and VLF_FADE_MODE_OUT, were specified, this param indicates + * wether to start from direction out or in. Otherwise, it is ignored. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetTextFade(VlfText text, int mode, int speed, int direction_out); + +/** + * Cancels a VlfText item fade. + * + * @param text - The text item to remove fade. + * + * @returns - < 0 on error +*/ +int vlfGuiCancelTextFade(VlfText text); + +/** + * Sets a callback to report the end of a fade. + * + * @param text - The text item fading. + * @param callback - The callback function that will be called at end of fade. + * @param param - param that will be passed to the callback function + * @param delay - The delay between the end of fade and the call to the callback + * + * @returns - < 0 on error +*/ +int vlfGuiSetTextFadeFinishCallback(VlfText text, void (* callback)(void *), void *param, int delay); + +/** + * Sets text item alignment + * + * @param text - The text item to set alignment + * @param alignment - One of VlfTextAlignment values + * + * @returns - < 0 on error +*/ +int vlfGuiSetTextAlignment(VlfText text, int alignment); + +/** + * Sets text position + * + * @param text - The text item to set position + * @param x - The x position + * @param y - The y position + * + * @returns - < 0 on error +*/ +int vlfGuiSetTextXY(VlfText text, int x, int y); + +/** + * Sets the font size of a text item + * + * @param text - The text to set font size + * @param size - The size of the font + * + * @returns - < 0 on error +*/ +int vlfGuiSetTextFontSize(VlfText text, float size); + +/** + * Returns the size of a text item. + * + * @param text - The text item yo get size from + * @param width - pointer to a variable that receives the width + * @param height - pointer to a variable that receivs the height + * + * @returns - < 0 on error +*/ +int vlfGuiGetTextSize(VlfText text, int *width, int *height); + +/** + * Sets a scrollbar in the specified text item. + * + * @param text - The text item + * @param height - The height of the scrollbar + * + * @returns - < 0 on error +*/ +int vlfGuiSetTextScrollBar(VlfText text, int height); + +/** + * Sets a scrollbar in the specified text item (with more options) + * + * @param text - The text item + * @param height - The height of the scrollbar + * @param dispx - displacement between text and scrollbar in X axis + * @param dispy - displacement between text and scrollbar in Y axis + * + * @returns - < 0 on error + */ +int vlfGuiSetTextScrollBarEx(VlfText text, int height, int dispx, int dispy); + +/** + * Removes a scrollbar of a text item + * + * @param text - The text item + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveTextScrollBar(VlfText text); + +/** + * Sets a character that will be replaced by a button icon + * + * @param ch - The character that will be replaced. + * @param button - The button used for the replacement, one of VlfButtonIcon + * + * @returns - < 0 on error +*/ +int vlfGuiChangeCharacterByButton(u16 ch, int button); + +/** + * Adds a new picture item from a buffer. + * Supported formats are GIM, TIM, BMP and PNG. + * + * @param data - The buffer with the picture + * @param size - The size of data buffer + * @param x - x position + * @param y - y position + * + * @returns - a new VlfPivture on success, NULL on error +*/ +VlfPicture vlfGuiAddPicture(void *data, int size, int x, int y); + +/** + * Adds a new picture item from a file. + * Supported formats are GIM, TIM, BMP and PNG. + * + * @param file - The file with the picture + * @param x - x position + * @param y - y position + * + * @returns - a new VlfPivture on success, NULL on error +*/ +VlfPicture vlfGuiAddPictureFile(char *file, int x, int y); + +/** + * Adds a new picture item from a resource. + * Supported formats are GIM, TIM, BMP and PNG. + * + * @param rco - The rco + * @param name - The name of the resource + * @param x - x position + * @param y - y position + * + * @returns - a new VlfPivture on success, NULL on error +*/ +VlfPicture vlfGuiAddPictureResource(char *rco, char *name, int x, int y); + +/** + * Removes a picture + * + * @param pic - The picture to remove + * + * @returns - < 0 on error. +*/ +int vlfGuiRemovePicture(VlfPicture pic); + +/** + * Sets a picture position. + * + * @param pic - The picture + * @param x - x position + * @param y - y position + * + * @returns - < 0 on error +*/ +int vlfGuiSetPictureXY(VlfPicture pic, int x, int y); + +/** + * Gets a picture size. + * + * @param pic - The picture + * @param width - pointer to a variable that receives the width + * @param height - pointer to a variable that receives the height + * + * @returns - < 0 on error +*/ +int vlfGuiGetPictureSize(VlfPicture pic, int *width, int *height); + +/** + * Sets the picture display area + * + * @param pic - The picture + * @param x - x position of the display area, relative to the top left corner of the picture. + * @param y - y position of the display area, relative to the top left corner of the picture. + * @param width - the width of the rectangle display area + * @param height - The height of the rectangle display area + * + * @returns - < 0 on error +*/ +int vlfGuiSetPictureDisplayArea(VlfPicture pic, int x, int y, int width, int height); + +/** + * Sets picture alpha blend operation. + * + * @param pic - the picture + * @param op - Blending operation (see pspgu.h) + * @param src - Blending function for source operand (see pspgu.h) + * @param dst - Blending function for dest operand (see pspgu.h) + * @param srcfix - Fix value for GU_FIX (source operand) + * @param destfix - Fix value for GU_FIX (dest operand) + * + * @returns - < 0 on error +*/ +int vlfGuiSetPictureAlphaBlend(VlfPicture pic, int op, int src, int dst, u32 srcfix, u32 dstfix); + +/** + * Clones (duplicate) a picture + * + * @param pic - The picture to clone + * @param real - If 0, then the picture is not totally copied, but only a reference. Otherwise, a total duplication is performed. + * @param x - The x position for the cloned picture + * @param y - The y position for the cloned picture + * + * @returns - The cloned picture +*/ +VlfPicture vlfGuiClonePicture(VlfPicture pic, int real, int x, int y); + +/** + * Sets picture visibility + * + * @param pic - The picture + * @param visible - boolean indicating visibility + * + * @returns - < 0 on error +*/ +int vlfGuiSetPictureVisibility(VlfPicture pic, int visible); + +/** + * Makes a picture blink + * + * @param pic - The picture to blink + * @param nshow - The number of frames the picture will be shown + * @param nhide - The number of frames the picture will be hidden + * + * @returns - < 0 on error +*/ +int vlfGuiSetPictureBlinking(VlfPicture pic, u32 nshow, u32 nhide); + +/** + * Animates a picture. + * Frames are created from rectangle areas of the picture. + * + * @param pic - The picture to animate + * @param w - The width of each frame, must be a divisor of picture width + * @param h - The height of each frame, must be a divisor of picture height + * @param frames - The number of frames each frame is drawn. + * @param vertical - If 0, animaction is created from rectangles in horizontal direction. Otherwise, from vertical direction. + * + * @returns - < 0 on error +*/ +int vlfGuiAnimatePicture(VlfPicture pic, int w, int h, int frames, int vertical); + +/** + * Makes a VlfPicture item to fade. + * + * @param pic - The picture item to fade. + * @param mode - Whatever OR combination of VlfFadeModesFlags + * @param speed - The fade speed, one of VlfFadeSpeed + * @param direction_out - If both, VLF_FADE_MODE_IN and VLF_FADE_MODE_OUT, were specified, this param indicates + * wether to start from direction out or in. Otherwise, it is ignored. + * + * @returns - < 0 on error. + */ +int vlfGuiSetPictureFade(VlfPicture pic, int mode, int effect, int direction_out); + +/** + * Cancels a VlfPicture item fade. + * + * @param pic - The picture item to remove fade. + * + * @returns - < 0 on error +*/ +int vlfGuiCancelPictureFade(VlfPicture pic); + +/** + * Sets a callback to report the end of a fade. + * + * @param pic - The picture item fading. + * @param callback - The callback function that will be called at end of fade. + * @param param - param that will be passed to the callback function + * @param delay - The delay between the end of fade and the call to the callback + * + * @returns - < 0 on error +*/ +int vlfGuiSetPictureFadeFinishCallback(VlfPicture pic, void (* callback)(void *), void *param, int delay); + +/** + * Adds a new shadowed picture from two buffers. + * + * @param pic - The buffer with the main picture + * @param pic_size - The size of the pic buffer + * @param shpic - The buffer with the shadow picture + * @param shpic_size - The size of the shpic buffer + * @param x - x position + * @param y - y position + * @param sh_offsx - distance between the main picture and the shadow (x) + * @param sh_offsy - distance between the main picture and the shadow (y) + * @param shadow_before - indicates if shadow should be painted before + * + * @returns - a new shadowed picture on success, NULL on error +*/ +VlfShadowedPicture vlfGuiAddShadowedPicture(void *pic, int pic_size, void *shpic, int shpic_size, int x, int y, int sh_offsx, int sh_offsy, int shadow_before); + +/** + * Adds a new shadowed picture from two files + * + * @param pic - The file with the main picture + * @param shpic - The file with the shadow picture + * @param x - x position + * @param y - y position + * @param sh_offsx - distance between the main picture and the shadow (x) + * @param sh_offsy - distance between the main picture and the shadow (y) + * @param shadow_before - indicates if shadow should be painted before + * + * @returns - a new shadowed picture on success, NULL on error +*/ +VlfShadowedPicture vlfGuiAddShadowedPictureFile(char *pic, char *shpic, int x, int y, int sh_offsx, int sh_offsy, int shadow_before); + +/** + * Adds a new shadowed picture from two resources. + * + * @param rco .- The resource file + * @param pic - The name of the resource with the main picture + * @param shpic - The name of the resource with the shadow picture + * @param x - x position + * @param y - y position + * @param sh_offsx - distance between the main picture and the shadow (x) + * @param sh_offsy - distance between the main picture and the shadow (y) + * @param shadow_before - indicates if shadow should be painted before + * + * @returns - a new shadowed picture on success, NULL on error +*/ +VlfShadowedPicture vlfGuiAddShadowedPictureResource(char *rco, char *pic, char *shpic, int x, int y, int sh_offsx, int sh_offsy, int shadow_before); + +/** + * Removes a shadowed picture + * + * @param sp - The shadowed picture to remove + * + * @returns - < 0 on error. +*/ +int vlfGuiRemoveShadowedPicture(VlfShadowedPicture sp); + +/** + * Sets shadowed picture visibility + * + * @param sp - The shadowed picture + * @param visible - boolean indicating visibility + * + * @returns - < 0 on error +*/ +int vlfGuiSetShadowedPictureVisibility(VlfShadowedPicture sp, int visible); + +/** + * Makes a shadowed picture blink + * + * @param sp - The shadowed picture to blink + * @param nshow - The number of frames the picture will be shown + * @param nhide - The number of frames the picture will be hidden + * + * @returns - < 0 on error +*/ +int vlfGuiSetShadowedPictureBlinking(VlfShadowedPicture sp, u32 nshow, u32 nhide); + +/** + * Animates a shadowed picture. + * Frames are created from rectangle areas of the picture. + * + * @param sp - The shadowed picture to animate + * @param w - The width of each frame of main picture, must be a divisor of main picture width + * @param h - The height of each frame of main picure, must be a divisor of main picture height + * @param ws - The width of each frame of shadow picture, must be a divisor of shadow picture width + * @param hs - The height of each frame of shadow picure, must be a divisor of shadow picture height + * @param frames - The number of frames each frame is drawn + * @param vertical - If 0, animaction is created from rectangles in horizontal direction. Otherwise, from vertical direction. + * + * @returns - < 0 on error + * + * @Example: vlfGuiAddWaitIconEx source code. Image is divided in 17x17 rectangles, each frame is drawn for 3 frames. + * + * VlfShadowedPicture vlfGuiAddWaitIconEx(int x, int y) + * { + * VlfShadowedPicture res = vlfGuiAddShadowedPictureResource("system_plugin_fg", "tex_busy", "tex_busy_shadow", x, y, 1, 1, 0); + * + * if (!res) + * return NULL; + * + * if (vlfGuiAnimateShadowedPicture(res, 17, 17, 17, 17, 3, 1) < 0) + * { + * vlfGuiRemoveShadowedPicture(res); + * return NULL; + * } + * + * return res; + * } +*/ +int vlfGuiAnimateShadowedPicture(VlfShadowedPicture sp, int w, int h, int ws, int hs, int frames, int vertical); + +/** + * Makes a VlfShadowedPicture item to fade. + * + * @param sp - The shadowed picture item to fade. + * @param mode - Whatever OR combination of VlfFadeModesFlags + * @param speed - The fade speed, one of VlfFadeSpeed + * @param direction_out - If both, VLF_FADE_MODE_IN and VLF_FADE_MODE_OUT, were specified, this param indicates + * wether to start from direction out or in. Otherwise, it is ignored. + * + * @returns - < 0 on error. + */ +int vlfGuiSetShadowedPictureFade(VlfShadowedPicture sp, int mode, int effect, int direction_out); + +/** + * Cancels a VlfShadowedPicture item fade. + * + * @param sp - The shadowed picture item to remove fade. + * + * @returns - < 0 on error + */ +int vlfGuiCancelShadowedPictureFade(VlfShadowedPicture sp); + +/** + * Sets a callback to report the end of a fade. + * + * @param sp - The shadowed picture item fading. + * @param callback - The callback function that will be called at end of fade. + * @param param - param that will be passed to the callback function + * @param delay - The delay between the end of fade and the call to the callback + * + * @returns - < 0 on error +*/ +int vlfGuiSetShadowedPictureFadeFinishCallback(VlfShadowedPicture sp, void (* callback)(void *), void *param, int delay); + +/** + * Adds a new battery icon at its default position. Icon created by this function must be manually operated by programmer. + * + * @param status - The status, one of VlfBatteryIconStatus + * @param blink - blinking flag + * + * @returns - a new VlfBatteryIcon item +*/ +VlfBatteryIcon vlfGuiAddBatteryIcon(u32 status, int blink); + +/** + * Adds a new battery icon (with more options). Icon created by this function must be manually operated by programmer. + * + * @param x - The x position + * @param y - The y position + * @param status - The status, one of VlfBatteryIconStatus + * @param blink - blinking flag + * + * @returns - a new VlfBatteryIcon item + */ +VlfBatteryIcon vlfGuiAddBatteryIconEx(int x, int y, u32 status, int blink); + +/** + * Adds a new battery icon at its default position. + * Icon created by this function is handled automatically by the library. + * + * @param timer_ms - The miliseconds the timer that checks the battery is executed. + * + * @returns - a new VlfBatteryIcon item +*/ +VlfBatteryIcon vlfGuiAddBatteryIconSystem(int timer_ms); + +/** + * Sets battery icon status. + * + * @param baticon - The battery icon + * @param status - The status, one of VlfBatteryIconStatus + * @param blink - blinking flag + * + * @returns - < 0 on error + * + * @Note: this function shouldn't be used with a battery icon created by vlfGuiAddBatteryIconSystem. +*/ +int vlfGuiSetBatteryIconStatus(VlfBatteryIcon baticon, int status, int blink); + +/** + * Removes a battery icon. + * + * @param baticon - The battery icon to remove + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveBatteryIcon(VlfBatteryIcon baticon); + +/** + * Adds a system clock. Only one clock is allowed currently + * + * @returns - < 0 on error. + * + * @Note: this function will change in future versions. +*/ +int vlfGuiAddClock(); + +/** + * Adds an animated wait icon at its default position in lower-right corner. + * + * @returns - a new wait icon. +*/ +VlfShadowedPicture vlfGuiAddWaitIcon(); + +/** + * Adds an animated wait icon at position choosed by programmer. + * + * @param x - x position + * @param y - y position + * + * @returns - a new wait icon. + */ +VlfShadowedPicture vlfGuiAddWaitIconEx(int x, int y); + +/** + * Adds a cross picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new cross picture +*/ +VlfShadowedPicture vlfGuiAddCross(int x, int y); + +/** + * Adds a circle picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new circle picture +*/ +VlfShadowedPicture vlfGuiAddCircle(int x, int y); + +/** + * Adds a triangle picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new triangle picture +*/ +VlfShadowedPicture vlfGuiAddTriangle(int x, int y); + +/** + * Adds a square picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new square picture +*/ +VlfShadowedPicture vlfGuiAddSquare(int x, int y); + +/** + * Adds an enter picture (cross or circle) + * + * @param x - x position + * @param y - y position + * + * @returns - a new enter picture +*/ +VlfShadowedPicture vlfGuiAddEnter(int x, int y); + +/** + * Adds a cancel picture (cross or circle) + * + * @param x - x position + * @param y - y position + * + * @returns - a new cancel picture +*/ +VlfShadowedPicture vlfGuiAddCancel(int x, int y); + +/** + * Adds a spinup picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new spinup picture +*/ +VlfShadowedPicture vlfGuiAddSpinUp(int x, int y); + +/** + * Adds a spindown picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new spindown picture +*/ +VlfShadowedPicture vlfGuiAddSpinDown(int x, int y); + +/** + * Adds an arrow left picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new arrow left picture +*/ +VlfShadowedPicture vlfGuiAddArrowLeft(int x, int y); + +/** + * Adds an arrow right picture. + * + * @param x - x position + * @param y - y position + * + * @returns - a new arrow right picture +*/ +VlfShadowedPicture vlfGuiAddArrowRight(int x, int y); + +/** + * Adds a new integer spin + * + * @param x - x position + * @param y - y position + * @param min - minim value of the spin + * @param max - max value of the spin + * @param cur - The initial integer value of the spin + * @param step - The step in which the value is increased/decreased + * @param loop - boolean indicating if the spin loops + * @param speed - The speed of the spin in milisecs + * @param initstate - the initial state of the spin, one of VLF_SpinState + * @param prefix - Prefix string, NULL if not needed + * @param suffix - Suffix string, NULL if not needed + * + * @returns - a new VlfSpin object on success, NULL on error +*/ +VlfSpin vlfGuiAddIntegerSpinControl(int x, int y, int min, int max, int cur, int step, int loop, int speed, int initstate, char *prefix, char *suffix); + +/** + * Removes a spin item + * + * @param spin - the spin to remove + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveSpinControl(VlfSpin spin); + +/** + * Sets spin state + * + * @param spin - the spin + * @param state - the state, one of VLF_SpinState + * + * @returns - < 0 on error +*/ +int vlfGuiSetSpinState(VlfSpin spin, int state); + +/** + * Sets integer minimum and maximum values for an integer spin + * + * @param spin - The integer spin + * @param min - the minimum value + * @param max - the maximum value + * + * @returns - < 0 on error +*/ +int vlfGuiSetIntegerSpinMinMax(VlfSpin spin, int min, int max); + +/** + * Gets the integer value of an integer spin + * + * @param spin - the integer spin + * @param value - pointer to a variable that receives the value + * + * @returns - < 0 on error +*/ +int vlfGuiGetIntegerSpinValue(VlfSpin spin, int *value); + +/** + * Sets the integer value of an integer spin + * + * @param spin - the integer spin + * @param value - the integer value to set + * + * @returns - < 0 on error +*/ +int vlfGuiSetIntegerSpinValue(VlfSpin spin, int value); + +/** + * Adds a new checkbox item + * By default the checkbox is created without focus and without check. + * When a checbox has focus, library handles automatically the press of enter button to change check state + * + * @param x - x position + * @param y - y position + * + * @returns - a new VlfCheckBox item on sucess, NULL on error +*/ +VlfCheckBox vlfGuiAddCheckBox(int x, int y); + +/** + * Removes a checkbox item + * + * @param cb - The checkbox to remove + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveCheckBox(VlfCheckBox cb); + +/** + * Sets checkbox check state + * + * @param cb - The checkbox to check/uncheck + * @param check - boolean indicating check + * + * @returns - < 0 on error +*/ +int vlfGuiSetCheckBoxCheck(VlfCheckBox cb, int check); + +/** + * Sets checkbox focus state + * + * @param cb - The checkbox + * @param focus - boolean indicating focus + * + * @returns - < 0 on error + */ +int vlfGuiSetCheckBoxFocus(VlfCheckBox cb, int focus); + +/** + * Boolean function that checks check state of a checkbox + * + * @param cb - the checkbox + * + * @returns 1 if the checkbox is checked, 0 otherwise +*/ +int vlfGuiIsCheckBoxChecked(VlfCheckBox cb); + +/** + * Boolean function that checks focus state of a checkbox + * + * @param cb - the checkbox + * + * @returns 1 if the checkbox has focus, 0 otherwise +*/ +int vlfGuiIsCheckBoxFocused(VlfCheckBox cb); + +/** + * Adds a new inputbox item with default width. + * By default the newly created inputbox is focused and of normal type. + * When a inputbox item is focused, library automatically handles press of enter button to show OSK. + * + * @param desc - description that will be shown in the OSK dialog. + * @param x - the x position + * @param y - the y position + * + * @returns - a new VlfInputBox on sucess, NULL on error +*/ +VlfInputBox vlfGuiAddInputBox(char *desc, int x, int y); + +/** + * Adds a new inputbox item. + * By default the newly created inputbox is focused and of normal type. + * When a inputbox item is focused, library automatically handles press of enter button to show OSK. + * + * @param desc - description that will be shown in the OSK dialog. + * @param x - the x position + * @param y - the y position + * @param width - width of the box + * + * @returns - a new VlfInputBox on sucess, NULL on error +*/ +VlfInputBox vlfGuiAddInputBoxEx(u16 *desc, int x, int y, int width); + +/** + * Removes an inputbox + * + * @param ib - the inputbox to remove + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveInputBox(VlfInputBox ib); + +/** + * Sets inputbox text from an ascii string + * + * @param ib - the inputbox + * @param text - the ascii string + * + * @returns - < 0 on error +*/ +int vlfGuiSetInputBoxText(VlfInputBox ib, char *text); + +/** + * Sets inputbox text from an unicode string + * + * @param ib - the inputbox + * @param text - the unicode string + * + * @returns - < 0 on error + */ +int vlfGuiSetInputBoxTextW(VlfInputBox ib, u16 *text); + +/** + * Sets inputbox text from a string with format + * + * @param ib - the inputbox + * @param fmt - the string with format + * + * @returns - < 0 on error + */ +int vlfGuiSetInputBoxTextF(VlfInputBox ib, char *fmt, ...); + +/** + * Gets inputbox text. + * + * @param ib - thei inputbox + * @param text - output buffer that receives the strig as unicode + * + * @returns - < 0 on error +*/ +int vlfGuiGetInputBoxText(VlfInputBox ib, u16 *text); + +/** + * Sets inputbox focus state + * + * @param ib - the inputbox + * @param focus - the focus state boolean + * + * @returns - < 0 on error +*/ +int vlfGuiSetInputBoxFocus(VlfInputBox ib, int focus); + +/** + * Boolean function that checks inputbox focus state + * + * @param ib - The inputbox + * + * @returns 1 if the inputbox has focus, 0 otherwise +*/ +int vlfGuiIsInputBoxFocused(VlfInputBox ib); + +/** + * Sets inputbox type (normal or password). + * + * @param ib - the inputbox + * @param type - the type to set, one of VLF_InputBoxType + * + * @returns - < 0 on error +*/ +int vlfGuiSetInputBoxType(VlfInputBox ib, int type); + +/** + * Makes a VlfInputBox item to fade. + * + * @param ib - The inputbox item to fade. + * @param mode - Whatever OR combination of VlfFadeModesFlags + * @param speed - The fade speed, one of VlfFadeSpeed + * @param direction_out - If both, VLF_FADE_MODE_IN and VLF_FADE_MODE_OUT, were specified, this param indicates + * wether to start from direction out or in. Otherwise, it is ignored. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetInputBoxFade(VlfInputBox ib, int mode, int effect, int direction_out); + +/** + * Cancels a VlfInputBox item fade. + * + * @param ib - The inputbox item to remove fade. + * + * @returns - < 0 on error +*/ +int vlfGuiCancelInputBoxFade(VlfInputBox ib); + +/** + * Sets a callback to report the end of a fade. + * + * @param ib- The inputbox item fading. + * @param callback - The callback function that will be called at end of fade. + * @param param - param that will be passed to the callback function + * @param delay - The delay between the end of fade and the call to the callback + * + * @returns - < 0 on error +*/ +int vlfGuiSetInputBoxFadeFinishCallback(VlfInputBox ib, void (* callback)(void *), void *param, int delay); + +/** + * Adds a new progressbar at default x position. + * + * @param y - y position + * + * @return - a new VlfProgressBar item on success, NULL on error +*/ +VlfProgressBar vlfGuiAddProgressBar(int y); + +/** + * Adds a new progressbar + * + * @param x - x position + * @param y - y position + * + * @return - a new VlfProgressBar item on success, NULL on error +*/ +VlfProgressBar vlfGuiAddProgressBarEx(int x, int y); + +/** + * Removes a progress bar + * + * @param pb - the progress bar to remove. + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveProgressBar(VlfProgressBar pb); + +/** + * Sets the progress of a progressbar + * + * @param pb - the progress bar + * @param perc - the percentage progress + * + * @returns - < 0 on error +*/ +int vlfGuiProgressBarSetProgress(VlfProgressBar pb, u32 perc); + +/** + * Makes a VlfProgressBar item to fade. + * + * @param pb - The progressbar item to fade. + * @param mode - Whatever OR combination of VlfFadeModesFlags + * @param speed - The fade speed, one of VlfFadeSpeed + * @param direction_out - If both, VLF_FADE_MODE_IN and VLF_FADE_MODE_OUT, were specified, this param indicates + * wether to start from direction out or in. Otherwise, it is ignored. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetProgressBarFade(VlfProgressBar pb, int mode, int effect, int direction_out); + +/** + * Cancels a VlfProgressBar item fade. + * + * @param pb - The progressbar item to remove fade. + * + * @returns - < 0 on error +*/ +int vlfGuiCancelProgressBarFade(VlfProgressBar pb); + +/** + * Sets a callback to report the end of a fade. + * + * @param pb - The progressbar item fading. + * @param callback - The callback function that will be called at end of fade. + * @param param - param that will be passed to the callback function + * @param delay - The delay between the end of fade and the call to the callback + * + * @returns - < 0 on error +*/ +int vlfGuiSetProgressBarFadeFinishCallback(VlfProgressBar pb, void (* callback)(void *), void *param, int delay); + +/** + * Adds a new scrollbar. (must be controlled by programmer) + * + * @param x - x position + * @param y - y position + * @param height - height of scrollbar + * @param sliderheight - height of slider + * + * @returns a new VlfScrollBar item on success, NULL on error +*/ +VlfScrollBar vlfGuiAddScrollBar(int x, int y, int height, int sliderheight); + +/** + * Removes a scrollbar itemm. + * + * @param sb - the scrollbar to remove + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveScrollBar(VlfScrollBar sb); + +/** + * Moves the slider of a scrollbar + * + * @param y - the new position of the slider + * + * @returns - < 0 on error +*/ +int vlfGuiMoveScrollBarSlider(VlfScrollBar sb, int y); + +/** + * Sets the height of the slider of a scrollbar + * + * @param sb - the scrollbar + * @param height - the new height for the slider + * + * @returns - < 0 on error. +*/ +int vlfGuiSetScrollBarSliderHeight(VlfScrollBar sb, int height); + +/** + * Sets the visibility of the items in a rectangle + * + * @param x - x position of rectangle + * @param y - y position of rectangle + * @param w - width of rectangle + * @param h - height of rectangle + * @param visible . boolean indicating visibility + * + * @returns - < 0 on error +*/ +int vlfGuiSetRectangleVisibility(int x, int y, int w, int h, int visible); + +/** + * Saves the visibility context in a rectangle area + * + * @param x - x position of rectangle + * @param y - y position of rectangle + * @param w - width of rectangle + * @param h - height of rectangle + * + * @returns - the visibility context. Use vlfGuiRestoreVisibilityContext to restore it, and vlfGuiFreeVisibilityContext to deallocate it. +*/ +void *vlfGuiSaveRectangleVisibilityContext(int x, int y, int w, int h); + +/** + * Restores a visibility context. + * + * @param ctx - the visibility context +*/ +void vlfGuiRestoreVisibilityContext(void *ctx); + +/** + * Deallocates memory used by a visibility context + * + * @param ctx - the visibility context +*/ +void vlfGuiFreeVisibilityContext(void *ctx); + +/** + * Makes all items within a rectangle to fade + * + * @param x - x position of rectangle + * @param y - y position of rectangle + * @param w - width of rectangle + * @param h - height of rectangle + * @param mode - Whatever OR combination of VlfFadeModesFlags + * @param speed - The fade speed, one of VlfFadeSpeed + * @param direction_out - If both, VLF_FADE_MODE_IN and VLF_FADE_MODE_OUT, were specified, this param indicates + * wether to start from direction out or in. Otherwise, it is ignored. + * + * @returns - < 0 on error. +*/ +int vlfGuiSetRectangleFade(int x, int y, int w, int h, int mode, int effect, int direction_out, void (* callback)(void *), void *param, int delay); + +/** + * Makes all items within a rectangle to blink + * + * @param x - x position of rectangle + * @param y - y position of rectangle + * @param w - width of rectangle + * @param h - height of rectangle + * @param nshow - the numbers of frames the items will be shown + * @param nhide - the numbers of frames the items will be hidden + * + * @returns - < 0 on error. + * + * @Note: currently not all kind of items can blink. This will be fixed in future. +*/ +int vlfGuiSetRectangleBlinking(int x, int y, int w, int h, u32 nshow, u32 nhide); + +/** + * Synchronizes the blinking of one item with the one of a second one + * + * @param dst - the destiny item + * @param dst_type - the type of the destiny object, one of VlfObjects + * @param src - the source item + * @param src_type - the type of source object, one of VlfObjects + * + * @returns - < 0 on error +*/ +int vlfGuiSetSynchronizedBlinking(void *dst, int dst_type, void *src, int src_type); + +/** + * Shows a message dialog. + * + * @param msg - the message dialog + * @param flags - a combination of VLF_MDType, VLF_MD_Buttons and VLF_MD_InitalCursor + * + * @returns - one of VLF_MD_ButtonRes +*/ +int vlfGuiMessageDialog(char *msg, u32 flags); + +/** + * Shows an error dialog. + * + * @param error - the system error code + * + * @returns - one of VLF_MD_ButtonRes +*/ +int vlfGuiErrorDialog(int error); + +/** + * Shows a net config dialog. + * Network libraries must be loaded before. + * + * @returns 0 if the connection was done. +*/ +int vlfGuiNetConfDialog(); + +/** + * Shows an OSK dialog. + * + * @param intext - the initial text of the OSK, NULL if no required + * @param desc - the description that will be shown in the OSK, NULL if no required + * @param outtext - the output text + * + * @returns 0 if the text was entered. +*/ +int vlfGuiOSKDialog(u16 *intext, u16 *desc, u16 *outtext); + +/** + * Shows one or two buttons with enter/cancel icons at bottom of screen. + * Button presses are handled by the library. + * + * @param button1 - a button code, one of VLF_DialogItem. < 0 if no required + * @param button2 - a button code, one of VLF_DialogItem- < 0 if no required + * @param automatic - if automatic is 0, button1 will be the left button and button2 will be right button. + * Otherwise, the buttons are rearranged automatically acording to current button configuration. + * @param enter_is_left - if automatic is 0, this button indicates which button is assigned enter. + * @param distance - the distance between the buttons, use VLF_DEFAULT for a default distance + * @param handler - the function that will be called when enter/cancel are pressed. The function shall return VLF_REMOVE_HANDLERS if it + * wants to cancel further events, VLF_REMOVE_OBJECTS to remove bottom dialog, or both to fully remove the bottom dialog. + * + * @returns - < 0 on error. +*/ +int vlfGuiBottomDialog(int button1, int button2, int automatic, int enter_is_left, int distance, int (* handler)(int enter)); + +/** + * Shows one or two buttons with enter/cancel icons at bottom of screen. + * Button presses are handled by the library. + * + * @param button1 - button string. NULL if no required + * @param button2 - button string. NULL if no required + * @param automatic - if automatic is 0, button1 will be the left button and button2 will be right button. + * Otherwise, the buttons are rearranged automatically acording to current button configuration. + * @param enter_is_left - if automatic is 0, this button indicates which button is assigned enter. + * @param distance - the distance between the buttons, use VLF_DEFAULT for a default distance + * @param handler - the function that will be called when enter/cancel are pressed, enter param indicates if enter was pressed, otherwise cancel was pressed. + * The function shall return VLF_REMOVE_HANDLERS if it wants to cancel further events, VLF_REMOVE_OBJECTS to remove buttons, + * or both to fully remove the bottom dialog. + * + * @returns - < 0 on error. + */ +int vlfGuiCustomBottomDialog(char *button1, char *button2, int automatic, int enter_is_left, int distance, int (* handler)(int enter)); + +/** + * Cancels (remove) the bottom dialog +*/ +void vlfGuiCancelBottomDialog(); + +/** + * Creates a central menu. + * Button presses of menu are automatically handled by the library + * + * @param noptions - number of options of the menu + * @param items - an array of noptions strings + * @param defaultsel- the index of the item with the initial selection + * @param handler - the function that will be called on enter button is pressed. sel param is the index of the selected item. + * The function shall return VLF_REMOVE_HANDLERS if it wants to cancel further events, VLF_REMOVE_OBJECTS to remove items, + * or both to fully remove the central menu. + * @param dispx - displacement relative to the default centered position (x) + * @param dispy - displacement relative to the default centered position (y) + * + * @returns - < 0 on error +*/ +int vlfGuiCentralMenu(int noptions, char **items, int defaultsel, int (* handler)(int sel), int dispx, int dispy); + +/** + * Cancels (remove) the central menu +*/ +void vlfGuiCancelCentralMenu(); + +/** + * Returns the current selected item of the central menu + * + * @returns - the selected item +*/ +int vlfGuiCentralMenuSelection(); + +/** + * Creates a lateral menu with current system color. + * Button presses of menu are automatically handled by the library + * + * @param noptions - number of options of the menu + * @param items - an array of noptions strings + * @param defaultsel- the index of the item with the initial selection + * @param handler - the function that will be called on enter button is pressed. sel param is the index of the selected item. + * The function shall return VLF_REMOVE_HANDLERS if it wants to cancel further events, VLF_REMOVE_OBJECTS to remove menu, + * or both to fully remove the lateral menu. + * @param y - y position of first item + * + * @returns - < 0 on error +*/ +int vlfGuiLateralMenu(int noptions, char **items, int defaultsel, int (* handler)(int sel), int y); + +/** + * Creates a lateral menu with desired color. + * Button presses of menu are automatically handled by the library + * + * @param noptions - number of options of the menu + * @param items - an array of noptions strings + * @param defaultsel- the index of the item with the initial selection + * @param handler - the function that will be called on enter button is pressed. sel param is the index of the selected item. + * The function shall return VLF_REMOVE_HANDLERS if it wants to cancel further events, VLF_REMOVE_OBJECTS to remove menu, + * or both to fully remove the lateral menu. + * @param y - y position of first item + * @param color - the color of the lateral menu + * + * @returns - < 0 on error +*/ +int vlfGuiLateralMenuEx(int noptions, char **items, int defaultsel, int (* handler)(int sel), int y, u32 color); + +/** + * Cancels (remove) the lateral menu + */ +void vlfGuiCancelLateralMenu(); + +/** + * Returns the current selected item of the lateral menu + * + * @returns - the selected item + */ +int vlfGuiLateralMenuSelection(); + +/** + * Creates a control for previous page handling. + * + * @param handler - the function that will be called when the previous button (left) is pressed. page parameter holds the page number. + * The function shall return VLF_REMOVE_HANDLERS if it wants to cancel further events, VLF_REMOVE_OBJECTS to remove control pics and text, + * or both to fully remove the control. + * + * @returns - < 0 on error +*/ +int vlfGuiPreviousPageControl(int (* handler)(int page)); + +/** + * Creates a control for next page handling. + * + * @param handler - the function that will be called when the next button (right) is pressed. page parameter holds the page number. + * The function shall return VLF_REMOVE_HANDLERS if it wants to cancel further events, VLF_REMOVE_OBJECTS to remove control pics and text, + * or both to fully remove the control. + * + * @returns - < 0 on error + */ +int vlfGuiNextPageControl(int (* handler)(int page)); + +/** + * Cancels (remove) previous page control +*/ +void vlfGuiCancelPreviousPageControl(); + +/** + * Cancels (remove) next page control + */ +void vlfGuiCancelNextPageControl(); + +/** + * Enable or disable page control.(it does not add/remove them). + * + * @param enable - enable or disable +*/ +void vlfGuiSetPageControlEnable(int enable); + +/** + * Adds a handler for an event. + * + * @param buttons - the button event, 0 if no event (will be called every frame) + * @param wait - wait for the handler to be added. Use 0 for no wait, and -1 to make this handler impossible to delay. + * @param func - the function that will be called when the event happens. + * @param param - custom param for the handler function. The function must return one or a combination of following values: + * + * VLF_EV_RET_NOTHING: normal return, it does nothing. + * VLF_EV_RET_REMOVE_EVENT: it removes the event (button press), so other handler doesn't receive it. + * VLF_EV_RET_REMOVE_HANDLERS: it removes this handler so that it won't receive more event notifications. + * VLF_EV_RET_DELAY: the event is delayed for specified number of miliseconds. VLF_EV_RET_DELAY | (X << 16), where 0 <= X <= 32727 + * VLF_EV_RET_DELAY_FRAME: the event is delayed for specified number of frames. VLF_EV_RET_DELAY_FRAME | (X << 16), where 0 <= X <= 4095 + * VLF_EV_RET_REFRESH_ON_DELAY: the event is refreshed after a delay, so that if button/s are kept pressed until after the event, it will receive it as a new event + * + * @returns - < 0 on error +*/ +int vlfGuiAddEventHandler(int buttons, int wait, int (* func)(void *), void *param); + +/** + * Adds a handler for an event. + * Unlike the previous function, this one adds the handler to the head instead of the tail. + * + * @param buttons - the button event, 0 if no event (will be called every frame) + * @param wait - wait for the handler to be added. Use 0 for no wait, and -1 to make this handler impossible to delay. + * @param func - the function that will be called when the event happens. + * @param param - custom param for the handler function. The function must return one or a combination of following values: + * + * VLF_EV_RET_NOTHING: normal return, it does nothing. + * VLF_EV_RET_REMOVE_EVENT: it removes the event (button press), so other handler doesn't receive it. + * VLF_EV_RET_REMOVE_HANDLERS: it removes this handler so that it won't receive more event notifications. + * VLF_EV_RET_DELAY: the event is delayed for specified number of miliseconds. VLF_EV_RET_DELAY | (X << 16), where 0 <= X <= 32727 + * VLF_EV_RET_DELAY_FRAME: the event is delayed for specified number of frames. VLF_EV_RET_DELAY_FRAME | (X << 16), where 0 <= X <= 4095 + * VLF_EV_RET_REFRESH_ON_DELAY: the event is refreshed after a delay, so that if button/s are kept pressed until after the event, it will receive it as a new event + * + * @returns - < 0 on error +*/ +int vlfGuiAddEventHandlerHead(int buttons, int wait, int (* func)(void *), void *param); + +/** + * Adds a handler for a negative event. + * + * @param buttons - the negative button event. For Example if you pass PSP_CTRL_CROSS, it will mean NOT PSP_CTRL_CROSS pressed. + * @param wait - wait for the handler to be added. Use 0 for no wait, and -1 to make this handler impossible to delay. + * @param func - the function that will be called when the event happens. + * @param param - custom param for the handler function. The function must return one or a combination of following values: + * + * VLF_EV_RET_NOTHING: normal return, it does nothing. + * VLF_EV_RET_REMOVE_EVENT: it removes the event (button press), so other handler doesn't receive it. + * VLF_EV_RET_REMOVE_HANDLERS: it removes this handler so that it won't receive more event notifications. + * VLF_EV_RET_DELAY: the event is delayed for specified number of miliseconds. VLF_EV_RET_DELAY | (X << 16), where 0 <= X <= 32727 + * VLF_EV_RET_DELAY_FRAME: the event is delayed for specified number of frames. VLF_EV_RET_DELAY_FRAME | (X << 16), where 0 <= X <= 4095 + * VLF_EV_RET_REFRESH_ON_DELAY: the event is refreshed after a delay, so that if button/s are kept pressed until after the event, it will receive it as a new event + * + * @returns - < 0 on error + */ +int vlfGuiAddNegativeEventHandler(int buttons, int wait, int (* func)(void *), void *param); + +/** + * Adds a handler for a negative event. + * Unlike the previous function, this one adds the handler to the head instead of the tail. + * + * @param buttons - the negative button event. For Example if you pass PSP_CTRL_CROSS, it will mean NOT PSP_CTRL_CROSS pressed. + * @param wait - wait for the handler to be added. Use 0 for no wait, and -1 to make this handler impossible to delay. + * @param func - the function that will be called when the event happens. + * @param param - custom param for the handler function. The function must return one or a combination of following values: + * + * VLF_EV_RET_NOTHING: normal return, it does nothing. + * VLF_EV_RET_REMOVE_EVENT: it removes the event (button press), so other handler doesn't receive it. + * VLF_EV_RET_REMOVE_HANDLERS: it removes this handler so that it won't receive more event notifications. + * VLF_EV_RET_DELAY: the event is delayed for specified number of miliseconds. VLF_EV_RET_DELAY | (X << 16), where 0 <= X <= 32727 + * VLF_EV_RET_DELAY_FRAME: the event is delayed for specified number of frames. VLF_EV_RET_DELAY_FRAME | (X << 16), where 0 <= X <= 4095 + * VLF_EV_RET_REFRESH_ON_DELAY: the event is refreshed after a delay, so that if button/s are kept pressed until after the event, it will receive it as a new event + * + * @returns - < 0 on error + */ +int vlfGuiAddNegativeEventHandlerHead(int buttons, int wait, int (* func)(void *), void *param); + +/** + * Removes an event handler. Use vlfGuiRemoveHandlerEx if you have used the same handler with different params. + * + * @param func - the handler function + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveEventHandler(int (* func)(void *)); + +/** + * Removes an event hnadler + * + * @param func - the handler function + * @param param - the parameter that was passed to one of the vlfGuiAddEventHandler functions. + * + * @returns - < 0 on error +*/ +int vlfGuiRemoveEventHandlerEx(int (* func)(void *), void *param); + +/** + * Boolean function that checks if a handler is registered + * + * @param func - the handler to be checked. + * + * @return - < 0 on error +*/ +int vlfGuiIsEventRegistered(int (* func)(void *)); + +/** + * Delays an event handler. Use vlfGuiSetEventDelayEx if you have used the same handler with different params. + * + * @param func - the handler function + * @param delay - the delay in milisecs + * + * @return - < 0 on error +*/ +int vlfGuiSetEventDelay(int (* func)(void *), u32 delay); + +/** + * Delays an event handler. + * + * @param func - the handler function + * @param param - the parameter that was passed to one of the vlfGuiAddEventHandler functions. + * @param delay - the delay in milisecs + * + * @return - < 0 on error + */ +int vlfGuiSetEventDelayEx(int (* func)(void *), void * param, u32 delay); + +/** + * Delays all events that can be delayed + * + * @param delay - the delay in milisecs + * + * @returns - < 0 on error +*/ +int vlfGuiDelayAllEvents(u32 delay); + + + +#endif