Développer sur Playstation 2

IntroductionTout d'abord afin de pouvoir programmer sur PS2 il va falloir construire les outils pour les deux processeurs de la console, soit l'Emotion Engine et l'Input/Ouput Processor. Pour cela, comme à l'accoutumée, il va faloir installer l'environnement de développement Cygwin. Nous pourrons ainsi compiler dans un environnement "Unix-like" sous WIndows, GCC et BINUTILS.

Pour cela téléchargez Setup.Exe et sélectionnez ce que vous voulez(les plus feignant ou les nouveaux, prennez tout! :))

Installez tout, mais prennez lez sources, car nous devrons recompiler quelques packages.

Téléchargez également ces 2 archives, car les plateformes cibles des outils ne sont pas disponibles par défaut pour les processerus EE et IOP.
Package 1
Package 2

Construction des outils pour le processeur Emotion Engine(EE - R5900);

Après l'installation de Cygwin, nous devons construire le cross-compiler pour le processeur EE de la PS2.
Préparons la structure des répertoires. Démarrez le shell de Cygwin et tapez:
$ cd /
$ mkdir GCC
$ cd GCC
$ mkdir build-gcc

Copiez les sources dans le répertoire GCC, puis tapez pour les .tar.gz:
$ gunzip nom_du_fichier.tar.gz
et pour les .tar.bz2:
$ bunzip2 nom_du_fichier.tar.bz2

Suivis ensuite de:
$ tar xf nom_du_fichier.tar

Vous devriez obtenir 3 dossiers, build-gcc, gnu-ee-binutils-gcc et gettext-0.10.35.

Avant de compiler EE-GCC, nous devons compiler gettext, librairie essentielle à la compilation.
Pour cela, tapons:
$ cd /gcc/gettext-0.10.35
A noter que les nouvelles versions ne sont pas toujours les plus propices au développement car certaines ne compileront pas sur notre environnement.

Configurons à présent notre makefile à l'aide de ./configure:
$ ./configure --prefix=/usr --with-included-gettext
puis compilons:
$ make

Vérifions notre compilation et installons les librairies et entêtes afin que le compilateur les trouve:
$ aliaspath='/usr/share/locale:/usr/local/share/locale'
$ make check
$ make install-strip

A présent libintl.a est dans le sous-réperoire intl, car il est requis pour la compilation de GCC.

Afin d'être parfaitement en accord avec le fonctionnement de la PS2, éditez /gcc/gnu-ee-binutils-gcc/ld/emulparams/elf32l5900.sh:

Ligne 5:
Changez: TEXT_START_ADDR=0xa0020000
en: TEXT_START_ADDR=0x00100000

Dans /gcc/gnu-ee-binutils-gcc/ld/ ldmain.c , ligne 22:
Changez: #include "emul-ops.h"
en: // #include "emul-ops.h"

Dans /gcc/gnu-ee-binutils-gcc/gas/ listing.c ligne 381:
Change: if (__isascii (c) && ! iscntrl (c))
en: if (isascii (c) && ! iscntrl (c))

Initialisons les variables d'environnment:

$ target=mips64r5900-sce-elf
$ prefix=/usr/local/ps2/$target
$ binaries=$prefix/bin
$ PATH=$binaries:$PATH

Commençons la compilation: $ cd /gcc/build-gcc

Puis copions notre fichier libintl.a déjà compilé:
$ mkdir intl
$ cp ../gettext-0.10.35/intl/libintl.a intl/

Configurons le makefile afin qu'il soit correctement initialisé sur le processeur de destination et les chemins:
$ ../gnu-ee-binutils-gcc/configure --target=$target --prefix=$prefix

Et c'est parti pour la compilation!
$ make all install
Nous avons désormais GCC cross-compilé pour le processeur Emotion Engine de la PS2 présent dans usr/local/ps2/mips64r5900-sce-elf/bin.

NOTE: pour quelques outils il est recommandé de créer quelques liens symboliques(spécialement pour les makefiles qui attent les outils EE comme ee-gg ou ee-ar).
Ainsi allons dans le répertoire "target" (dans ce tutorial /usr/local/ps2/mips64r5900-sce-elf) et tapons: $ ln -s mips64r5900-sce-elf-gcc ee-gcc
$ ln -s mips64r5900-sce-elf-ar ee-ar
$ ln -s mips64r5900-sce-elf-ld ee-ld

Au cas où ce ne seraient pas assez vous pourriez lier tous les autres outils pour r5900 de même ! :)

En cas de problèmes, il s'agit probablement de la variable sys_errlist(déclarée 2 fois), pour cela éditez /usr/include/sys/errno.h:
Cherchez la variable et commentez afin d'obtenir ceci:
/* Please don't use these variables directly.
Use strerror instead. *
// extern __IMPORT _CONST char * _CONST _sys_errlist[];
extern __IMPORT int _sys_nerr;
#ifdef __CYGWIN__
// extern __IMPORT const char * const sys_errlist[];

Construction des outils pour le processeur IOP (R3000);

Ici la compilation pour l'Input/Output Processor est quasiment la même que pour la chaîne d'outils du EE. Nous ne nous occuperons pas du fichier
libintl.a puisqu'il est déjà là où il devrait être. Si vous avez déjà construit la chîne pour l'EE, vous commencez à être habitué! :)

Attention! Changez bien le target surtout! Sinon vous gâcheriez votre première compilation...Et croyez moi rie n'est plus rageant! :)
$ target=mipsel-scei-elfl
$ prefix=/usr/local/ps2/$target
$ binaries=$prefix/bin
$ PATH=$binaries:$PATH

Allons dans le répertoire de GCC:
$ cd /gcc/build-gcc

Si vous venez de compiler pour l'EE, faites un petit nettoyage:
$ make clean
Configurons le makefile afin qu'il soit correctement initialisé sur le processeur de destination et les chemins:
$ ../gnu-ee-binutils-gcc/configure --target=$target --prefix=$prefix

Et encore et toujours:
$ make all install
C'est au tour du compilateur GCC pour l'Input/Output Processor d'être disponible dans /usr/local/ps2/mipsel-scei-elfl/bin.

Pour la suite c'est comme pour l'EE(cf explications :))
$ ln -s mipsel-scei-elfl-gcc iop-gcc
$ ln -s mipsel-scei-elfl-ar iop-ar
$ ln -s mipsel-scei-elfl-ld iop-ld

Et vous pouvez encore lier tous les outils au pire :D
Construire l'assembleur VU;

Maintenant que les deux processeurs sont utilisables par GCC, il nous manque toujours le support de l'assembleur, utilisé par le VU.
Le VU est le Vector Units. Nous devons faire une petite modification dans un fichier de configuration pour activer la compilation les sources pour le DVP.

Ouvrez config.sub dans le répertoire /gcc/gnu-ee-binutils-gcc:

Recherchez les lignes:

# Recognize the basic CPU types without company name.
# Some are omitted here because they have special[...]
tahoe | i860 | ia64 | m32r | m68k | m68000[...]
et remplacez par:
# Recognize the basic CPU types without company name.
# Some are omitted here because they have special[...]
tahoe | dvp | i860 | ia64 | m32r | m68k | m68000[...]
A noter qu'il faut ajouter la partie en italique.

Changeons maintenant les variables comme tout à l'heure:
$ target=dvp-elf
$ prefix=/usr/local/ps2/$target
$ binaries=$prefix/bin
$ PATH=$binaries:$PATH

$ cd /gcc/build-gcc

Maintenant pour chaque répertoire, dont voici le listing:
- libiberty
- bfd
- opcodes
- binutils
- ld
- gas

tapez après être entré dedans à l'aide de la commande "cd dossier_en_question":
linkons le répertoire de libintl.a: $ ln -s ../intl
puis configurons le avec: $ ../../gnu-ee-binutils-gcc/configure --target=$target --prefix=$prefix

Puis créeons tout:
$ make all install

Il faut que nous fassions cela pour chacun des dossiers sus-cités.
A noter que rien ne vous empêche de faire un script qui automatiserait tout cela.
Maintenant nous avons un assembleur fonctionnel pour VU0/VU1 présent dans /usr/local/ps2/dvp-elf/bin.

Compiler PSX2LIB; Maintenant que nous pouvons tout faire avec nos compilateurs et assembleur, il est temps de passé à ce pour quoi nous avons mis
temps de temps à configurer: la programmation! Et pour cela nous avons besoin de PSX2LIB

La première chose à faire est de downloader les packages :)
Téléchargez-les!

Les destinations devraient déjà être présente, mais au cas où ajoutez ces lignes à votre .bash.rc ou .profile dans votre /home/utilisateur:
target=mipsel-scei-elfl
prefix=/usr/local/ps2/$target
binaries=$prefix/bin
PATH=$binaries:$PATH

Copier psx2lib-1.0b-2002xxxx.tar.bz2 dans un répertoire de votre choix (comme /home/utilisateur/ps2dev);
Désarchivez comme ceci:
$ tar -jxf psx2lib-1.0b-2002xxxx.tar.bz2

Puis allez dans le répertoire ainsi crée.

Changeons le path de la racine de PSX2LIB. Editez environ-ee.sh (également à faire avec environ-iop.sh) : export PSX2LIB_BASE="~/ps2dev/psx2lib-1.0b"

Maintenant lançons notre script:
$ . ./environ-ee.sh
Le "." devant est essentiel puisqu'il permettra au script de se répéeter automatiquement à chaque lancement du shell.

Compilons désormais la partie de la librairie pour le EE:
$ make
Exécutons maintenant l'environnement IOP:
$ . ./environ-ee.sh
Compilons désormais la partie de la librairie pour l'IOP:
$ make

Nous avons désormais une libraire de développement GNU compilée pour le processeur Emotion Engine de la PS2.

Dès que vous voulez utiliser la librairie dans votre shell pour la compilation EE vous devez appeller le script environ-ee.sh
et environ-iop.sh pour l'IOP!

Tester les librairies et le compilateur;
Pas encore :)

Ecrire, compilation, puis test d'un premier programme;
Pas encore :)

Création d'un CD;
Pas encore :)