assembleur - gestion L2

[bro7]

Bonjour à tous.
Mon but est de gérer les infos du registre de cache de mon G3 (L2CR), en particulier les 3 bits qui gèrent la fréquence (L2CLK).
Typiquement, je veux un programme qui lise ces infos, et qui puisse les modifier.
Pour ce faire, j'ai besoin d'instructions ASM. Mais je suis plutôt un développeur JAVA. Alors j'ai bien lu des milliards de docs, j'ai bien fait des recherches sur le forum, j'ai bien suivi les liens, mais.... c'est pas concluant. Je me suis dit qu'en bon débutant, je voudrais d'abord faire un prog comme ça :

<essai.c>
void asmAdd(int *a, int *b, int *c); // ma fonction add en asm

int main(void) {
int i = 4;
int j = 5;
int k;
asmAdd(&i, &j, &k); // la partie de mon prog en asm
printf("%i\n", k); // affiche 9
}

<asmAdd.s>
; je veux c = a + b
; et là je mets quoi ????
; un truc comme mflr r11 ?
; puis addis r11, r11, 16 ?
; ... en fait je sais pas du tout !!!

Vous voyez le truc ? Un programme en C qui appelle 2 mauvaises routines en ASM avec passage de paramètres.

Et bêinh vous me croyez, vous me croyez pas, j'ai rien trouvé de clair ni concis sur le sujet .... sauf peut-être en x86, mais là, c'est un tout autre monde.

Bref, vous avez une idée ?
D'avance merci.
La biz.
ob1

 

[Membre supprimé 2]

Dans ton cas le mieux a utiliser c'est la fonction de gcc qui te permet d'utiliser directement de l'assembleur dans ton code:
#include <stdio.h>
int main(void) {
int i = 4;
int j = 5;
int k = 0;
__asm__("add %0,%1,%2\n" : "=r" (k) : "r" (j), "r" (i)); // la partie de mon prog en asm
printf("%i\n", k); // affiche 9
}

Mais pour la doc y en a un bon paquet chez IBM...

Hf++

 

[steg]

Tiens, de plus vla quelque definition provenant des sources de netbsd qui devraient te servir...

#define SPR_L2PM 0x3f8 /* .6. L2 Private Memory Control Register */
#define SPR_L2CR 0x3f9 /* .6. L2 Control Register */
#define L2CR_L2E 0x80000000 /* 0: L2 enable */
#define L2CR_L2PE 0x40000000 /* 1: L2 data parity enable */
#define L2CR_L2SIZ 0x30000000 /* 2-3: L2 size */
#define L2SIZ_2M 0x00000000
#define L2SIZ_256K 0x10000000
#define L2SIZ_512K 0x20000000
#define L2SIZ_1M 0x30000000
#define L2CR_L2CLK 0x0e000000 /* 4-6: L2 clock ratio */
#define L2CLK_DIS 0x00000000 /* disable L2 clock */
#define L2CLK_10 0x02000000 /* core clock / 1 */
#define L2CLK_15 0x04000000 /* / 1.5 */
#define L2CLK_20 0x08000000 /* / 2 */
#define L2CLK_25 0x0a000000 /* / 2.5 */
#define L2CLK_30 0x0c000000 /* / 3 */
#define L2CR_L2RAM 0x01800000 /* 7-8: L2 RAM type */
#define L2RAM_FLOWTHRU_BURST 0x00000000
#define L2RAM_PIPELINE_BURST 0x01000000
#define L2RAM_PIPELINE_LATE 0x01800000
#define L2CR_L2DO 0x00400000 /* 9: L2 data-only.
Setting this bit disables instruction
caching. */
#define L2CR_L2I 0x00200000 /* 10: L2 global invalidate. */
#define L2CR_L2CTL 0x00100000 /* 11: L2 RAM control (ZZ enable).
Enables automatic operation of the
L2ZZ (low-power mode) signal. */
#define L2CR_L2WT 0x00080000 /* 12: L2 write-through. */
#define L2CR_L2TS 0x00040000 /* 13: L2 test support. */
#define L2CR_L2OH 0x00030000 /* 14-15: L2 output hold. */
#define L2CR_L2SL 0x00008000 /* 16: L2 DLL slow. */
#define L2CR_L2DF 0x00004000 /* 17: L2 differential clock. */
#define L2CR_L2BYP 0x00002000 /* 18: L2 DLL bypass. */
#define L2CR_L2IP 0x00000001 /* 31: L2 global invalidate in */
/* progress (read only). */
int l2cr;
__asm __volatile ("mfspr %0,%1" : "=r"(l2cr) : "n"(SPR_L2CR));

Hf++

 

[bro7]

MERCI !!!
Merci bcp steg parce que tu as vraiment fait avancer mon schmilblik !!!
Grâce à toi, je sais passer des paramètres (ha! ha! ma fonction addition !!!) et accéder à certains registres !!! Là vraiment merci.

Il me reste 2 soucis :
- si je comprends bien l'expression __asm__ comme "exécute une fonction asm", que signifie "__asm __volatile" ? Et les espaces sont-ils bien placés. Ne faudrait-il pas écrire "__asm__ volatile" ? C'est comme ça que ProjectBuilder reconnaît la syntaxe.
- mon seconde problème est d'accèder aux registres du mode OEA : PVR (0x11f) et L2CR (0x39). Pour l'instant je n'ai accès qu'aux registres du mode UISA.

Je continue à rechercher mais un grand merci à toi !!!

La biz,
ob1

 

[steg]

Pour le __asm__ volatile, c'est mieux avec un espace

Tu utilises le mot clef volatile lorsque tu sais que tes variables peuvent changer sans que le compilateur soit au courant (une interruption ou autre est responsable)... Ca peut paraitre un peu flou, mais cherche dans google 'volatile C' et tu trouveras une bonne explication illustrée...
Pour acceder au PVR (dispo uniquement en lecture) tu as l'instruction mfspr.
Par contre pour le L2CR, et les autres il va falloir envisager la creation d'une extension du kernel pour les manipuler sans contrainte...

Have fun...