Alors voilà. ça fait longtemps que ça me trotte dans la tête. A savoir, seulement flasher la zone "perfirmware" d'une NOR plutôt que de flasher la NOR entière à chaques coups. Un peu sur le modèle du "differential flashing" sur NANDs.
Ceci est beaucoup plus safe étant donnée que l'on ne touche pas aux données "perconsole" si importantes. Je ne vais pas développer, tout le monde comprend bien l’intérêt de la chose.
Je sais depuis longtemps que norway est sensé être capable de flasher a partir d'une adresse donnée (d'un block donné) mais je ne m'étais jamais réellement penché sur la question. Peut être certains d'entre vous utilisent déjà cette fonction. Ci c'est le cas, les témoignages sont bien venus
Pour les heureux possesseur de E3 flasher.... je ne sais pas trop si c'est possible. Je ne connait pas la bête. En tout cas ce serait bien car ce sont eux qui en auraient le plus besoin. Progskeet, je ne sais pas non plus.
Pour ma part j'ai un peu gratté le sujet et je pense bien cerner le truc avec Teensy et norway.
Je vous fait donc part ici de la théorie. Et une sorte de tuto "bêta"
Commençons par le commencement. un simple rappel :
Les données perfirmwares sont constituées des TRKs (revokation packages et programs), des ROS (stockage des fichiers du Core OS). Il y a deux zones de chaque utilisés alternativements à chaque update. Ainsi que du vFlash (fichiers systèmes). Le vFlash ne nous concerne pas sur les NOR car il est stocké sur le HDD.
Quand on "patch" notre "dump", on modifie ces données. En fait on les remplace par celles provenant d'un CFW. (Tout du moins les ROS. Pour les TRVK ce n'est indispensable que pour un downgrade 3.55 via FSM. Mais là je m'égare déjà)
Conclusion : la différence entre un dump original est un dump patché ne réside que dans les données perfirmwares contenues dans la NOR. Donc, si on modifie seulement ces données directement dans la NOR, ça revient au même que de dumper la NOR entière, la patcher, et réécrire la NOR entière avec notre dump patché.
Note : bien que l'on puisse écrire directement les données perconsole, il est plus que très vivement conseiller de dumper et vérifier avant. Ne serait-ce que pour s'assurer du bon câblage.
J'espère que jusque là tout le monde est sur la même longueur d'onde.
Entrons maintenant dans le vif du sujet.
Ce que peut faire norway (basé sur la v0.7) :
Traduction :
On peut dire à Norway à partir de quelle adresse, dans la NOR, il doit commencer à écrire (ou effacer, ou vérifier). Par défaut c'est 0x0 (le début de la NOR. logique). Il est aussi indiqué que les adresses doivent être un multiple de 0x20000 (soit 131072 octets, soit 131072/1024 = 128ko. Ce qui représente la taille d'un block. J'y reviendrais plus loin.)
Ceci est un petit peu succin me direz-vous. Et je suis tout à fait d"accord.
Les questions en suspend sont du type:
- Il commence à écrire mais il s’arrête quand? (on a, entre autre, le booldr en fin de NOR et on ne veux pas y toucher)
- On flash en prenant le dump complet pour modèle? Ou un autre type de fichier?
Pour y répondre, il faut farfouiller dans le code de norway pour comprendre comment ça fonctionne. Attention, ça risque de piquer un peu les yeux de certains mais j'ai essayé de traduire en vulgarisant au mieux.
On y trouve donc, pour un "write":
Voilà pour la migraine. Mais si vous ne voulez pas trop vous torturer l'esprit, je résume:
- norway écrit block par block de 128KB (il y a des nuances pour les Samsung K8Q2815UQB mais je ne vais pas entrer dans ces détails inutiles).
- on peut lui demander de commencer à un block particulier en donnant son adresse (un multiple de 128KB, donc un multiple de 0x20000).
- norway écrira la totalité du contenu du fichier (dump), à partir de l'adresse définie, et ne s’arrêtera seulement que quand il aura écrit la totalité des données contenues dans ce fichier (ou jusqu’à ce qu'il arrive à la fin de la NOR...).
- Si la taille du fichier (dump) ne correspond pas à un multiple de la taille d'un block, il tronquera les dernières donnèes (il ne les écrira pas).
Fort de ce constat, il apparait que ce n'est plus un dump complet que l'on doit utiliser pour le write partiel, mais un morceau de dump (ou un assemblage de patch) regroupant les données perfirware que nous voulons écrire. Et pas plus. La taille de ce fichier devra être un multiple exact de 0x20000 (128KB).
Les données perfirmware:
Comme dis en préambule, ce sont les TRVKs ROSs. Regardons d'un peu plus près afin de voir si ça rentre dans les clous (adresse et taille d'un multiple de 0x20000):
D’après la bible (wiki), voici les données perfirmware, leur adresse et taille:
Name Start Offset End Offset Size (h)
trvk_prg0 0x040000 0x05FFFF 0x20000
trvk_prg1 0x060000 0x07FFFF 0x20000
trvk_pkg0 0x080000 0x09FFFF 0x20000
trvk_pkg1 0x0A0000 0x0BFFFF 0x20000
ros0 0x0C0000 0x7BFFFF 0x700000
ros1 0x7C0000 0xEBFFFF 0x700000
Première bonne nouvelle, toutes ces données sont contiguës. Donc on peut les écrire en "one shot" à l'aide d'un seul fichier.
Deuxième bonne nouvelle, ces données commencent à une adresse qui est un multiple de 0x20000 ( 0x40000 )
Troisième bonne nouvelle, l'ensemble de ces données est également un multiple de 0x20000:
0x20000 x 4 + 0x700000 x 2 = 0xE80000 (taille totale des données perfirmware)
0xE80000 / 0x20000 = 116 (soit 116 blocks complets)
Toutes les conditions sont là
A noter que l'on pourrait aussi se contenter des ROSs avec une taille totale de 112 block commençant à l'adresse 0xC0000 (0x20000 x 6).
Voilà, niveau théorie c'est bordé. Passons à la pratique.
Création d'un fichier (dump) perfirmware:
On pourait en créer un de toute pièce à partir des patchs existants mais ce serait un peu pénible et il faudrait renseigner quelque données supplémentaires (ROS headers).
Bref, le plus simple est de partir sur un dump propre patché.
Le petit tuto, à l'aide de HxD:
- Dumpez votre NOR, vérifiez votre dump et patchez le comme vous avez l'habitude.
- Ouvrez votre dump patché avec HxD puis sélectionnez et copiez l'ensemble des données perconsoles (offset 0x40000, taille 0xE80000) :
- Créez un nouveau fichier, collez-y les données puis enregistrez:
C’est tout.
Nous avons désormais nos données perconsoles pour flasher. Un fichier d'une taille de 15204352 octets exactement (0xE80000). Soit 14848Ko ou encore 14,5Mo.
(Notez que les données perfirmware sont 90% du dump complet. On ne gagnera pas grand chose en temps de flash).
Ces données peuvent être flashées sur n'importe quelle console évidemment. Et il n'est pas besoin de refaire la manip pour chaque console temps que vous ne voulez pas changer de type de patch.
perfirmware patchés 4.75 no-fsm : https://www.dropbox....atched.zip?dl=1
perfirmware patché 3.55 FSM : https://www.dropbox....atched.zip?dl=1
C'est partie pour le flash:
Donc là, rien de sorcier. C'est un write classique, seulement on utilise le fichier de données perfirmware et l'adresse ou elles doivent être écrites. 0x40000 en l'occurence (ne pas oublier le "0x" devant et ne pas oublier de "0" sinon ça ne sera pas écrit là ou il faut...):
norway.py com6 vwrite perfw475_patched.bin 0x40000Une fois fait, vous pouvez dumper à nouveau et comparer avec votre dump patché. Ils devraient être strictement identique.
Voici une petite démonstration en video:
Modifié par littlebalup, 03 août 2015 - 21:55.