Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Je vous remercie d'avance pour vos suggestions,
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Je vous remercie d'avance pour vos suggestions,
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Je vous remercie d'avance pour vos suggestions,
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
C'est pourtant assez propre pour du C. Si à la place de part1 tu mets u n nom
comme reg, alors ton code C sera du type :
base->reg.truc = 42;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
C'est pourtant assez propre pour du C. Si à la place de part1 tu mets u n nom
comme reg, alors ton code C sera du type :
base->reg.truc = 42;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
C'est pourtant assez propre pour du C. Si à la place de part1 tu mets u n nom
comme reg, alors ton code C sera du type :
base->reg.truc = 42;
Bonjour,
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Je vous remercie d'avance pour vos suggestions,
Jérôme Arbez-Gindre
PS : j'utilise gcc (versions récentes) et suis ouvert aux extansions
de celui-ci
Bonjour,
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Je vous remercie d'avance pour vos suggestions,
Jérôme Arbez-Gindre
PS : j'utilise gcc (versions récentes) et suis ouvert aux extansions
de celui-ci
Bonjour,
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Je vous remercie d'avance pour vos suggestions,
Jérôme Arbez-Gindre
PS : j'utilise gcc (versions récentes) et suis ouvert aux extansions
de celui-ci
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
N'auras-tu pas aussi vite fait de dissocier le port
et la représentation dans le code ?J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
Ouij'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Est-ce bien grave ?
Je vous remercie d'avance pour vos suggestions,
strut regs_t{
uint8_t a1;
uint8_t a2;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
};
#define OFFSET_a1 0
#define OFFSET_a2 sizeof(uint8_t)
#define OFFSET_big_buffer 0x00080000UL
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), size of(reg->big_buffer) );
}
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
N'auras-tu pas aussi vite fait de dissocier le port
et la représentation dans le code ?
J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
Oui
j'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Est-ce bien grave ?
Je vous remercie d'avance pour vos suggestions,
strut regs_t{
uint8_t a1;
uint8_t a2;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
};
#define OFFSET_a1 0
#define OFFSET_a2 sizeof(uint8_t)
#define OFFSET_big_buffer 0x00080000UL
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), size of(reg->big_buffer) );
}
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
N'auras-tu pas aussi vite fait de dissocier le port
et la représentation dans le code ?J'ai donc écris quelque chose qui ressemble à ça:
#define BIG_BUFFER_LOCATION 0x00080000UL /*512Ko*/
#define BIG_BUFFER_SIZE 0x00080000UL /*512Ko*/
struct regs_t {
union {
struct { c
uint32_t a1 ;
uint32_t a2 ;
} ;
uint8_t before_big_buffer[BIG_BUFFER_LOCATION] ;
} ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
Mais je trouve ça assez "moche"... et ça risque devenir très vite
illisible (mon exemple ci-dessus est condensé !)
Ouij'ai pensé faire quelque chose comme ça :
struct regs_t {
struct part1_t{
uint32_t a1 ;
uint32_t a2 ;
} part1 ;
uint8_t __padding0 [BIG_BUFFER_LOCATION-sizeof (struct part1_t)] ;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
} ;
mais ça m'oblige à donner ajouter une indirection syntaxique pour
accéder à "a1" par exemple, ce qui ne me plait pas non plus.
Est-ce bien grave ?
Je vous remercie d'avance pour vos suggestions,
strut regs_t{
uint8_t a1;
uint8_t a2;
uint8_t big_buffer[BIG_BUFFER_SIZE] ;
};
#define OFFSET_a1 0
#define OFFSET_a2 sizeof(uint8_t)
#define OFFSET_big_buffer 0x00080000UL
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), size of(reg->big_buffer) );
}
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
Dans ce cas, il n'y a pas de perte d'espace mémoire, c'est de la
mémoire mappée sur un périphérique (dont je ne maitrise pas le
mapping)
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), sizeof(reg->big_buffer) );
}
Mon idée, c'est d'écrire
regs->some_feature_enable = true ;
plutôt que
write_reg (base+SOME_FEATURE_ENABLE_OFFSET, true) ;
Ce qui me parait plus lisible et plus élégant.
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
Dans ce cas, il n'y a pas de perte d'espace mémoire, c'est de la
mémoire mappée sur un périphérique (dont je ne maitrise pas le
mapping)
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), sizeof(reg->big_buffer) );
}
Mon idée, c'est d'écrire
regs->some_feature_enable = true ;
plutôt que
write_reg (base+SOME_FEATURE_ENABLE_OFFSET, true) ;
Ce qui me parait plus lisible et plus élégant.
Pour acceder à des ports I/O, je souhaiterai définir une structure et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
Dans ce cas, il n'y a pas de perte d'espace mémoire, c'est de la
mémoire mappée sur un périphérique (dont je ne maitrise pas le
mapping)
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), sizeof(reg->big_buffer) );
}
Mon idée, c'est d'écrire
regs->some_feature_enable = true ;
plutôt que
write_reg (base+SOME_FEATURE_ENABLE_OFFSET, true) ;
Ce qui me parait plus lisible et plus élégant.
<GAG_ON>
#define REGS_T struct{ uint32_t a1 ; uint32_t a2 ;}
typedef struct regs_t_nopad{
REGS_T;
uint8_t a;
}regs_t_nopad;
struct regs_t{
REGS_T;
uint8_t __padding0[BIG_BUFFER_LOCATION - offsetof(regs_t_nopad,
a)];
uint8_t big_buffer[BIG_BUFFER_SIZE];
};
<GAG_OFF>
<GAG_ON>
#define REGS_T struct{ uint32_t a1 ; uint32_t a2 ;}
typedef struct regs_t_nopad{
REGS_T;
uint8_t a;
}regs_t_nopad;
struct regs_t{
REGS_T;
uint8_t __padding0[BIG_BUFFER_LOCATION - offsetof(regs_t_nopad,
a)];
uint8_t big_buffer[BIG_BUFFER_SIZE];
};
<GAG_OFF>
<GAG_ON>
#define REGS_T struct{ uint32_t a1 ; uint32_t a2 ;}
typedef struct regs_t_nopad{
REGS_T;
uint8_t a;
}regs_t_nopad;
struct regs_t{
REGS_T;
uint8_t __padding0[BIG_BUFFER_LOCATION - offsetof(regs_t_nopad,
a)];
uint8_t big_buffer[BIG_BUFFER_SIZE];
};
<GAG_OFF>
Pour acceder à des ports I/O, je souhaiterai définir une structu re et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
Dans ce cas, il n'y a pas de perte d'espace mémoire, c'est de la
mémoire mappée sur un périphérique (dont je ne maitrise pas le
mapping)
Mais as-tu des variables de type regs_t dans ton code, ou te
contentes-tu de faire des cast entre des adresses memoires
(celles des ports) et un reg_t* ?
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), s izeof(reg->big_buffer) );
}
Mon idée, c'est d'écrire
regs->some_feature_enable = true ;
plutôt que
write_reg (base+SOME_FEATURE_ENABLE_OFFSET, true) ;
Ce qui me parait plus lisible et plus élégant.
Mon idée (mais peut-être pas du tout adapté à ton contexte),
c'est de préparer la structure avant de l'envoyer en mémoire.
reg_t val;
val.some_feature_enable = true ;
val.other_thing= false;
val.param_truc= 64;
write_reg(&val, port);
Mais si on passe son temps à faire de mini-modifs,
ça n'a pas d'intérêt.
Pour acceder à des ports I/O, je souhaiterai définir une structu re et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
Dans ce cas, il n'y a pas de perte d'espace mémoire, c'est de la
mémoire mappée sur un périphérique (dont je ne maitrise pas le
mapping)
Mais as-tu des variables de type regs_t dans ton code, ou te
contentes-tu de faire des cast entre des adresses memoires
(celles des ports) et un reg_t* ?
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), s izeof(reg->big_buffer) );
}
Mon idée, c'est d'écrire
regs->some_feature_enable = true ;
plutôt que
write_reg (base+SOME_FEATURE_ENABLE_OFFSET, true) ;
Ce qui me parait plus lisible et plus élégant.
Mon idée (mais peut-être pas du tout adapté à ton contexte),
c'est de préparer la structure avant de l'envoyer en mémoire.
reg_t val;
val.some_feature_enable = true ;
val.other_thing= false;
val.param_truc= 64;
write_reg(&val, port);
Mais si on passe son temps à faire de mini-modifs,
ça n'a pas d'intérêt.
Pour acceder à des ports I/O, je souhaiterai définir une structu re et
la mapper à mes ports.
Est-ce vraiment une bonne idée ? Tu vas te prendre la tête
à écrire une structure de donnée pas portable, avec perte
d'espace mémoire (BIG_BUFFER_LOCATION - 2* sizeof(uint8_t) ),
tout ça pour faire des accès en memcpy ?
Dans ce cas, il n'y a pas de perte d'espace mémoire, c'est de la
mémoire mappée sur un périphérique (dont je ne maitrise pas le
mapping)
Mais as-tu des variables de type regs_t dans ton code, ou te
contentes-tu de faire des cast entre des adresses memoires
(celles des ports) et un reg_t* ?
void write_reg_t(const reg_t* reg, void* port_adr){
memcpy(((char*) port_adr) + OFFSET_a1, &(reg->a1), sizeof(reg->a1) );
memcpy(((char*) port_adr) + OFFSET_a2, &(reg->a2), sizeof(reg->a2) );
memcpy(((char*) port_adr) + OFFSET_big_buffer, &(reg->big_buffer), s izeof(reg->big_buffer) );
}
Mon idée, c'est d'écrire
regs->some_feature_enable = true ;
plutôt que
write_reg (base+SOME_FEATURE_ENABLE_OFFSET, true) ;
Ce qui me parait plus lisible et plus élégant.
Mon idée (mais peut-être pas du tout adapté à ton contexte),
c'est de préparer la structure avant de l'envoyer en mémoire.
reg_t val;
val.some_feature_enable = true ;
val.other_thing= false;
val.param_truc= 64;
write_reg(&val, port);
Mais si on passe son temps à faire de mini-modifs,
ça n'a pas d'intérêt.