Kit de desarrollo libre para PS3

embedded

Hola amigüitos! si sois alegres poseedores de una PS3 con FW3.50 o anterior y tenéis a vuestra disposición algún dispositivo jailbreaker sabréis que la ejecución de programas caseros o homebrew está en vuestras manos. Pero claro, eso para está web no es nada... a nosotros nos gusta más desarrollar esos programas caseros. Existen por internet varios SDK's oficiales filtrados, pero que no debéis usar (ni, por tanto, publicar aplicaciones compiladas con esos kits). Es ilegal que los uséis porque no tenéis la licencia, así que si encontráis alguno, como material didáctico están muy bien, pero hasta ahí su utilidad práctica. En esta receta explicaremos cómo compilarnos nuestro propio kit de desarrollo legal para hacer nuestras aplicaciones caseras legales que correrán en cosolas jailbreakadas.

Qué necesitamos

Bueno, nuestra distro tiene que contar con los siguientes paquetes:
# aptitude install git libelf-dev python zlib-dev autotools autoconf automake bison flex gcc make autotools patch subversion wget texinfo
Lamentablemente puede que se me olvide alguno, si es así rogaría que me lo comentaseis.

Ahora necesitamos un sitio donde meterlo todo, es decir, /usr/local/. Ahí crearemos un directorio y le daremos permisos de escritura al grupo staff (al que perteneceremos) para no tener que hacer las cosas como root:
# cd /usr/local
# mkdir ps3dev
# chown root:staff ps3dev
# chmod 775 ps3dev

Vale y ahora ajustaremos las variables de entorno para que todo quede bien organizadito (estas lineas, además de ejecutarlas, añadirlas en vuestro ~/.bashrc o similar) (esto hacedlo ya como vuestro usuario):
$ export PS3DEV=/usr/local/ps3dev
$ export PATH=$PATH:$PS3DEV/bin
$ export PATH=$PATH:$PS3DEV/ppu/bin
$ export PATH=$PATH:$PS3DEV/spu/bin

Bien, con esto podremos compilarnos e instalar la toolchain, pero nos hará falta el SDK para poder crear nuestros ejecutables para la PS3. Le haremos sitio al SDK de la siguiente manera:
$ cd $PS3DEV
$ mkdir psl1ght

Y de la misma manera que antes, creamos la variable de entorno (meted esto también en vuestro ~/.bashrc):
$ export PSL1GHT=$PS3DEV/psl1ght

Vale, ya lo tenemos todo listo... ahora a descargar y compilar...

Compilar e instalar la toolchain

Bueno, yo tengo mi directorio ~/repos donde guardo todas estas cosas, vosotros podéis meterlo donde os plazca... si lo hacéis como yo:
$ cd ~/repos

Y a descargar:
$ git clone https://github.com/ooPo/ps3toolchain.git

Cuando esto termine: a compilar, parchear e instalar, es decir:
$ cd ps3toolchain
$ ./toolchain.sh

Y esto tardará la vidaaaa... (bueno, según vuestros sistemas...) el caso es que tiene que crear dos toolchains una para el PowerPC (conocido como PPU) y otra para los Synergistic Processors (conocidos como SPU's).

Atención: debido a que algunas URL's que utiliza el script pueden estar offline, habría que realizar los siguientes cambios en estos scripts: scripts/002-gcc-4.5.1-PPU-stage1.sh, scripts/004-gcc-4.5.1-PPU-stage2.sh, scripts/007-gcc-4.5.1-SPU-stage1.sh y scripts/009-gcc-4.5.1-SPU-stage2.sh
La línea:

wget --continue http://www.mpfr.org/mpfr-2.4.2/mpfr-2.4.2.tar.bz2 || { exit 1; }

sustituirla por:

wget --continue http://ftp.gnu.org/gnu/mpfr/mpfr-2.4.2.tar.bz2 || {exit 1; }

Si todo ha salido bien podréis hacer algo como:
$ ppu-gcc --version
ppu-gcc (GCC) 4.5.1
Copyright (C) 2010 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ spu-gcc --version
spu-gcc (GCC) 4.5.1
Copyright (C) 2010 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compilar e instalar el SDK: PSL1GHT

Bueno, como antes, si tenéis vuestros repos en ~/repos haced lo siguiente y si no, hacedlo donde queráis:
$ cd ~/repos

Descargamos el SDK:
$ git clone https://github.com/HACKERCHANNEL/PSL1GHT.git

Cuando esto termine: a compilar, parchear e instalar, es decir:
$ cd PSL1GHT
$ make
$ make install

Como su nombre indica... es ligerito así que no tardará mucho... después de esto ya estaréis en condiciones de crear vuestros programas para la PS3... peero...

Algunas librerías útiles

Si queremos instalarnos algunas librerías portadas a la PS3 como zlib, libpng, libjpeg, freetype, pixman, libogg, libvorbis, libzip o incluso cairo, haremos lo siguiente:

$ cd ~/repos

Descargamos los scripts de ooPo que es muy majo:
$ git clone https://github.com/ooPo/ps3libraries.git

Y a compilar e instalar, es decir:
$ cd ps3libraries
$ ./libraries.sh

Ya tenemos bastantes cositas para empezar a programar un hola mundo y algo más... pero como ya os dije antes, hay muchas librerías útiles por ahí que podemos ir instalando según nuestra necesidad.

vpcomp: compilador de programas de vértices

Primero: ¿qué demonios es esto? pues más o menos lo siguiente: resulta que para mover vértices y todo ese rollo, los señores de NVIDIA han creado una especie de "máquina virtual", la cual interpreta una serie de opcodes para trabajar con datos escalares y vectoriales. En la PS3 esta máquina virtual puede interpretarse mediante una SPU, pero claro, alguien debe compilar esos programas de vértices en estos opcodes para la SPU, esto es: vpcomp

Requisitos no muy libres

Bueno, esto necesita el NVidia Cg Toolkit que es un compilador/intérprete de una especie de lenguaje ensamblador para OpenGL, podemos descargarnos gratis del NVIDIA Cg website. Descargaros el tgz de vuestra arquitectura (x86 o x86/64).

Ahora viene una cutrez: no vamos a instalar este paquete en nuestro sistema (bueno, si vosotros queréis dadle caña, lo tenéis también como paquete Debian). Como sólo necesitamos una biblioteca, vamos descomprimir el tgz y a copiar sólo lo que necesitamos en /usr/local (suponemos que estamos en el directorio donde descargamos el fichero):
$ unp Cg-3.0_November2010_x86.tgz
$ cp usr/lib/libCg.so /usr/local/lib/
$ cp -r usr/lib/include/Cg /usr/local/include/
$ sudo ldconfig

La última línea refresca la caché de bibliotecas, para asegurarnos que la tenemos "disponible".

Compilar e instalar

Bien, ya podemos volver al repositorio de PSL1GHT para compilarnos el compilador...
$ cd PSL1GHT/psl1ght/tools/vpcomp
$ make

Se siente, el Makefile no tiene el target install, así que a manímetro:
$ cp vpcomp $PSL1GHT/bin/

Y ya tenemos listo nuestro compilador de vértices... Eye-wink

Tiny3D: algo parecido al OpenGL en la PS3

Si, el RSX devora OpenGL que da gusto... pero para explotar eso (por ahora) tendríamos que echar mano del SDK oficial así que por ahora nos contentaremos con el magnífico Tiny3D de Hermes.

Requisitos

Todos los pasos anteriores, incluído el vpcomp.

Compilación e instalación

Pues nada, en nuestro directorio de repositorios:
$ git clone https://github.com/hermesEOL/tiny3d.git
$ cd tiny3d
$ make all

Si no hay ningún error, estaremos listos para usar la biblioteca. En tiny3d/docs tenéis un documentillo sobre la biblioteca y el RSX de la PS3.

ps3soundlib: audio fácil para nuestros programas

También gracias a Hermes tenemos esta biblioteca que nos permite utilizar samples de 8 y 16 bits en mono y stereo. Reproducir los samples en loop, una vez , o incluso llamando a un callback al finalizar. En fin... más cositas útiles.

Requisitos

Los pasos para obtener la toolchain y el PSL1GHT, con eso es suficiente...

Compilar e instalar

Desde nuestro directorio de repositorios:
$ git clone https://github.com/hermesEOL/ps3soundlib.git
$ cd ps3soundlib
$ make
$ make install

Al igual que antes, si no obtuvimos ningún error, ya tendremos la biblioteca lista para usar en nuestros homebrews.

Guinda: la librería SDL

Antes de que alguien se lleve a equívocos, hace tiempo que SDL fue oficialmente portado a PS3, entonces: ¿para qué todo esto?. Pues fácil, el port en realidad es para el OtherOS, es decir, algún GNU/Linux que tengáis corriendo en aquellas PS3 con un FW que disponga de esa opción. Y os permitiría crear aplicaciones para esa distribución. En cambio este port os permitirá crear aplicaciones que utilicen SDL de forma nativa en la PS3. Es decir, sin necesidad de OtherOs ni nada por el estilo: compiláis, obtenéis un PKG que podréis instalar y a funcionar... Eye-wink

Requisitos

Los pasos para obtener la toolchain, el PSL1GHT y las ps3libraries (ya sabéis: Algunas librerías útiles).

Compilación e instalación

Como siempre, desde nuestro directorio de repositorios:
$ git clone https://github.com/cebash/SDL_PSL1GHT.git
$ cd SDL_PSL1GHT
$ ./script.sh
$ make
$ make install

Y si no tuvimos ningún error tendremos libSDL listo para usar en nuestras aplicaciones homebrew.

Y ya está... creo que con esto podremos empezar a hacer nuestras aplicaciones caseras. De todas formas existen más librerías y utilidades por ahí que según vaya probando iré añadiendo en la receta, ok?

Para terminar: Makefile

Os pongo un Makefile típico para que os cree los targets automáticos para generar los archivos PKG que contienen nuestras aplicaciones y que podremos instalar en la consola para ejecutar/distribuír nuestras creaciones.

.SUFFIXES:
ifeq ($(strip $(PSL1GHT)),)
$(error "PSL1GHT must be set in the environment.")
endif

include $(PSL1GHT)/Makefile.base

TARGET		:=	$(notdir $(CURDIR))
BUILD		:=	build
SOURCE		:=	source
INCLUDE		:=	include
DATA		:=	data
LIBS		:=	-lzip -lz -lgcm_sys -lreality -lsysutil -lio -ljpgdec -lnet -lsysmodule

TITLE		:=	Hello World - PSL1GHT
APPID		:=	TEST00003
CONTENTID	:=	UP0001-$(APPID)_00-0000000000000000

CFLAGS		+= -g -O2 -Wall --std=gnu99
CXXFLAGS	+= -g -O2 -Wall

ifneq ($(BUILD),$(notdir $(CURDIR)))

export OUTPUT	:=	$(CURDIR)/$(TARGET)
export VPATH	:=	$(foreach dir,$(SOURCE),$(CURDIR)/$(dir)) \
					$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export BUILDDIR	:=	$(CURDIR)/$(BUILD)
export DEPSDIR	:=	$(BUILDDIR)

CFILES		:= $(foreach dir,$(SOURCE),$(notdir $(wildcard $(dir)/*.c)))
CXXFILES	:= $(foreach dir,$(SOURCE),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES		:= $(foreach dir,$(SOURCE),$(notdir $(wildcard $(dir)/*.S)))
BINFILES	:= $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.bin)))

export OFILES	:=	$(CFILES:.c=.o) \
					$(CXXFILES:.cpp=.o) \
					$(SFILES:.S=.o) \
					$(BINFILES:.bin=.bin.o)

export BINFILES	:=	$(BINFILES:.bin=.bin.h)

export INCLUDES	:=	$(foreach dir,$(INCLUDE),-I$(CURDIR)/$(dir)) \
					-I$(CURDIR)/$(BUILD)

.PHONY: $(BUILD) clean pkg run

$(BUILD):
	@[ -d $@ ] || mkdir -p $@
	@make --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile

clean:
	@echo Clean...
	@rm -rf $(BUILD) $(OUTPUT).elf $(OUTPUT).self $(OUTPUT).a $(OUTPUT).pkg

pkg: $(BUILD)
	@echo Creating PKG...
	@mkdir -p $(BUILD)/pkg
	@mkdir -p $(BUILD)/pkg/USRDIR
	@cp $(ICON0) $(BUILD)/pkg/
	@$(FSELF) -n $(BUILD)/$(TARGET).elf $(BUILD)/pkg/USRDIR/EBOOT.BIN
	@$(SFO) --title "$(TITLE)" --appid "$(APPID)" -f $(SFOXML) $(BUILD)/pkg/PARAM.SFO
	@$(PKG) --contentid $(CONTENTID) $(BUILD)/pkg/ $(OUTPUT).pkg

run: $(BUILD)
	@$(PS3LOADAPP) $(OUTPUT).self

else

DEPENDS	:= $(OFILES:.o=.d)

$(OUTPUT).self: $(OUTPUT).elf
$(OUTPUT).elf: $(OFILES)
$(OFILES): $(BINFILES)

-include $(DEPENDS)

endif

Está sacado del ejemplo Hola mundo del PSL1GHT.

Ps3sdk Builder

Bueno, aquí podréis encontrar un proyecto propio en fase ultrabeta quick & dity pero que instala (probado) el toolchain, el psl1ght, las ps3libraries y la sdl_psl1ght configurando las variables de entorno y todo ese rollo. ¡Cuidado porque no comprueba que tengáis los paquetes necesarios comentados en la receta!.
Ps3sdk-Builder at github.com

Disfruten! Laughing out loud

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de brue

Buen post.

+1

A ver si CRySoL sortea una PS3 ... que sé de una que no se usa ni de posavasos :D

brue

Imagen de int-0

Jeje...

...gracias... pues la verdad que es un trasto muy interesante para cacharrear. En vez de este SDK se puede usar el toolchain de IBM para arquitectura CELL... y es muy divertido Eye-wink

------------------------------------------------------------
$ python -c "print 'VG9udG8gZWwgcXVlIGxvIGxlYSA6KQ==\n'.decode('base64')"
------------------------------------------------------------