Flasher son modchip PSnee sur un ATtiny85 avec une arduino uno sous Linux

Dans cet article on s'intéresse aux étapes nécessaires pour faire un "hardmod"(?) sur notre chère console PSX pour permettre la lecture d'utilitaires et de jeux homebrew, voire des copies de sauvegardes de vos jeux.

Hardmod, ça veut dire qu'on va aller faire des modifs directement sur la console. À contrario, il existe ce qu'on appelle "softmod" et qui consiste à retrouver les mêmes fonctions, sans modifier la console, en passant par une cartouche de type "Action Replay" ou "Game Hunter", qui se branche sur le port parallèle présent sur la console jusqu'au modèle SCPH-7503.

Ça se passe ici pour cette seconde solution !

Matériel nécessaire

Malgré les nombreux liens, je ne suis pas sponsorisé par Reichelt :) Pour flasher l'ATtiny :

Une Arduino Uno ou équivalent .
un ATtiny45/85
un condensateur 10uf/25V
une breadboard et des fils de pontage

Pour tester l'ATtiny :

une led
une pile bouton 3.3v, type CR2032

Pour installer le modchip dans la console:

un tournevis cruciforme
un fer à souder
du câble fin, récupéré dans un RJ45 ou une nappe IDE
un isolant adhésif, genre scotch électricien

Configurer l'arduino pour flasher de l'ATtiny25/45/85

Dans un premier temps, il faut installer l'IDE arduino depuis votre gestionnaire de paquet.
Installer la librairie spécifique pour Attiny25/45/85 depuis le gestionnaire de bibliothèque.

Pour cela, lancer l'IDE, puis dans le menu "Fichiers" > "Préférences", Coller l'url suivante dans le champ "URL de gestionnaire de carte supplémentaires" :

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Ensuite, dans "Outils" > "Type de carte" > "Gestionnaire de carte", installer "attiny".

Connecter l'arduino Uno via USB, puis vérifier les réglages suivants dans le menu "Outils":

Type de carte: "Arduino Uno" Port : /dev/ttyACM* Il faut vérifier que vous avez bien le droit d'écrire sur le port de l'arduino. Pour cela, dans un terminal :

$ ls -la /dev/ttyACM0 
crw-rw---- 1 root uucp 166, 0 16 mai 17:36 /dev/ttyACM0

Ici on peut voir que l'utilisateur root et le groupe uucp ont accès à la carte en lecture et écriture. Il faut donc que votre utilisateur fasse partie du groupe uucp.

La commande groups sous Linux permet de lister les groupes dont l'utilisateur actuel fait partie.

$ groups 
sys lp wheel uucp network video audio optical power usb  Ici c'est

uucp est bien dans la liste.

Si ce n'est pas le cas :

 $ sudo usermod -a -G uucp nom_d_utilisateur

Après cela, il faut vous déconnecter de votre session et vous reconnecter pour que le changement soit pris en compte.

Flasher le sketch "ArduinoISP" sur votre arduino Uno :

Ouvrez de nouveau l'IDE Arduino, puis "Fichiers" > "Exemples" > "11.ArduinoISP" > "ArduinoISP" Un nouveau sketch s'ouvre, cliquez sur le bouton "Téléverser".

Passer en mode "Arduino as ISP" : Menu "Outils" > "Programmateur" > "Arduino as ISP"
Dans le menu "Outils" > "Type de carte" > "ATtiny25/45/85".
Dans le menu "Outils" > "Processeur" > "ATtiny85".
Dans le menu "Outils" > "Clock" > "Internal 8Mhz".

Votre arduino est configurée pour flasher des ATtiny25/45/85. Il faut maintenant faire un petit montage sur une breadboard pour pouvoir téléverser du code sur votre micro controlleur.

Montage électronique

Il y a un détrompeur sur l'ATtiny, sous la forme d'un petit poinçon. Il faut le mettre vers le haut dans le schéma suivant :

attiny pinout arduino for attiny flashing

Voici les connexions à effectuer :

Uno    <–> ATtiny85
-------------------
5V     <–> Vcc
Gnd    <–> Gnd
Pin 13 <–> Pin 2
Pin 12 <–> Pin 1
Pin 11 <–> Pin 0
Pin 10 <–> Reset

Le condensateur est à placer entre "Reset" et "GND", le - vers "GND".

Graver la séquence d'initialisation

Une fois le montage effectué, il faut charger le bootloader :

menu "Outils" > "Graver la séquence d'initialisation".

Premier test

Pour tester que le téléversement se fait bien, ouvrir le sketch
"Blink" : "Fichiers" > "Exemples" > "1.Basics" > "Blink".

Ajouter avant void setup() { (ligne 26) la déclaration suivante:

short LED_BUILTIN = 0;

ce qui donne :

short LED_BUILTIN = 0;
void setup() {

  // initialize digital pin LED_BUILTIN as an output. 
  pinMode(LED_BUILTIN, OUTPUT); 
}

Une fois téléversé, le montage suivant permet de vérifier que la LED clignote :

attiny blink

Cette première partie est une traduction adaptée de cette page : https://create.arduino.cc/projecthub/arjun/programming-attiny85-with-arduino-uno-afb829

Flasher PsNee

Changer les FUSE sur l'ATtiny :

PsNee demande une confirmation spécifique des FUSE sur l'ATtiny, que ce soit 45 ou 85 :

LFUSE 0xE2 HFUSE 0xDF

Avec la commande avrdude, on va changer le mode des FUSE comme suit, dans un terminal :

$ avrdude -pattiny85 -cstk500v1 -P /dev/ttyACM0 -b19200 -e -Uefuse:w:0xFF:m -Uhfuse:w:0xDF:m -Ulfuse:w:0xE2:m

avrdude: AVR device initialized and ready to accept instructions

Reading |
####################################################################################################
| 100% 0.02s

avrdude: Device signature = 0x1e9206 (probably t45) avrdude: erasing
chip avrdude: reading input file "0xFF" avrdude: writing efuse (1
bytes):

Writing |
####################################################################################################
| 100% 0.01s

avrdude: 1 bytes of efuse written avrdude: verifying efuse memory
against 0xFF: avrdude: load data efuse data from input file 0xFF:
avrdude: input file 0xFF contains 1 bytes avrdude: reading on-chip efuse
data:

Reading |
####################################################################################################
| 100% 0.01s

avrdude: verifying ... avrdude: 1 bytes of efuse verified avrdude:
reading input file "0xDF" avrdude: writing hfuse (1 bytes):

Writing |
####################################################################################################
| 100% 0.01s

avrdude: 1 bytes of hfuse written avrdude: verifying hfuse memory
against 0xDF: avrdude: load data hfuse data from input file 0xDF:
avrdude: input file 0xDF contains 1 bytes avrdude: reading on-chip hfuse
data:

Reading |
####################################################################################################
| 100% 0.01s

avrdude: verifying ... avrdude: 1 bytes of hfuse verified avrdude:
reading input file "0xE2" avrdude: writing lfuse (1 bytes):

Writing |
####################################################################################################
| 100% 0.02s

avrdude: 1 bytes of lfuse written avrdude: verifying lfuse memory
against 0xE2: avrdude: load data lfuse data from input file 0xE2:
avrdude: input file 0xE2 contains 1 bytes avrdude: reading on-chip lfuse
data:

Reading |
####################################################################################################
| 100% 0.01s

avrdude: verifying ... avrdude: 1 bytes of lfuse verified

avrdude: safemode: Fuses OK (E:FF, H:DF, L:E2)

avrdude done. Thank you.

Source : https://forum.arduino.cc/index.php?topic=341285.0

Pensez à modifier pattiny85 en fonction de votre modèle. Modifier si besoin le chemin d'accès /dev/ttyACM0

Télécharger le sketch "PsNee.ino" depuis le git : https://github.com/kalymos/PsNee .
À la ligne 43, décommenter :


##define ARDUINO_BOARD

#define ATTINY_X5

Si vous avez une PSone (le modèle "slim"), il faut aussi décommenter la ligne 45 :

#  define APPLY_PSONE_PAL_BIOS_PATCH

Si vous voulez gagner un peu de temps au démarrage, il est également possible de commenter des instructions entre les lignes 439 et 443 en fonction de la région de votre PSX.

Pour une console PAL :


    inject_SCEX('e'); // e = SCEE, a = SCEA, i = SCEI 
    //inject_SCEX('a'); // injects all 3 regions by default 
    //inject_SCEX('i'); // optimize boot time by sending only your console region letter (all 3 times per loop)

Une fois les modifications effectuées, vérifier et téléverser le code.

C'est fait ! Plus qu'à installer le modchip dans votre PSX.

Installation du modchip

Modèle de PSX et révision de la carte mère

En fonction de votre modèle de PSX, la révision de la carte mère ne sera pas la même. Sous la console se trouve une étiquette avec un numéro de modèle commençant par "SCPH-...".

Trouvez le dans le tableau suivant et vous pourrez dans la 5ème colonne trouver la carte mère qui équippe votre console, dont le numéro est du type "PU-...".

Trouver le bon montage

Une fois que vous connaissez la révision de votre carte mère, vous pourrez trouver sur cette autre page un lien vers des instructions spécifiques : https://quade.co/ps1-modchip-guide/psnee/

Une fois vos soudures effectuées et vos traces vérifiées, il vous reste à graver un jeux Homebrew comme Marilyn: In the MagicWorld ou un utilitaire du type ImportPlayer Light pour vérifier que le CD boot correctement.

Réinitialiser les fuse du attiny

Si vous souhaitez retrouver les paramêtres par défaut du attiny, il suffit d'utiliser l'option ;

Outils > Graver la séquence d'initialisation

qui correspond à la commande suivante :

avrdude -C$HOME/.arduino15/packages/arduino/tools/avrdude/6.3.0-arduino17/etc/avrdude.conf -v -v -v -v -pattiny85 -cstk500v1 -P/dev/ttyACM0 -b19200 -e -Uefuse:w:0xff:m -Uhfuse:w:0xdf:m -Ulfuse:w:0xe2:m

Sources & Liens

https://github.com/kalymos/PsNee
https://github.com/Kippykip/PSX-Modchip
https://www.instructables.com/id/Program-an-ATtiny-with-Arduino/
https://forum.arduino.cc/index.php?topic=341285.0
https://quade.co/ps1-modchip-guide/psnee/
https://fr.wikipedia.org/wiki/Liste_des_mod%C3%A8les_de_la_PlayStation##Comparaison_des_mod%C3%A8les
http://www.psxdev.net/homebrew.html