Auf feste Adresse im embedded Linux Schreiben

[Tobias W. (wagnertobse)]

Hallo,

Ich versuche in einen embedded Linux auf einen ARROW SoCkit auf eine 
feste Adresse (0x00010080) zu schreiben. Um eine virtuelle Adresse mit 
der gewünschten Adresse zu erstellen nutze ich mmap. Leider habe ich im 
bereich speicher zugriff unter Linux nicht viel erfahrungen...

Schreibe im mit folgenden Code auf die Adresse?

#include "hwlib.h"
#include "socal/socal.h"
#include "socal/hps.h"
#include "socal/alt_gpio.h"
#include "system.h"


int main(){
  void *virtual_base;
  void *adresse = 0x00010080;
  unsigned int fd;
  unsigned int in = 0xFFFF9FFF;
  unsigned int out;
  if( ( fd = open( "/dev/mem", ( O_RDWR | O_SYNC ) ) ) == -1 ) {
    printf( "ERROR: could not open \"/dev/mem\"...\n" );
    return( 1 );
  }

  virtual_base = mmap( adresse, 32, ( PROT_READ | PROT_WRITE ), MAP_SHARED, fd , 0 );

  if( virtual_base == MAP_FAILED ) {
    printf( "ERROR: mmap() failed...\n" );
    close( fd );
    return( 1 );
  }

  alt_write_word( virtual_base, in );

  out = alt_read_word(virtual_base);
  printf("%i wurde zurueckgegeben!!",out);
  return 0;
}

[S. R. (svenska)]

Was passiert bei
*virtual_base = in;
printf("%i\n", *virtual_base);
?

[Tobias W. (wagnertobse)]

Theoretisch dürfte ich auf der Adresse nur schreiben können aber 
alt_red_word gibt mein auf die Adresse glegeten Wert zurück. Auf der 
Adresse sitzt eine Bridge zum FPGA, die in der Aktuellen konfiguration 
nur schreiben kann. Auf dem FPGA kommt leider nichts an :(

[./. (Gast)]

Damit ein mmap Erfolg hat, muss etwas zum 'mmap'en da sein.
Z.B. durch ein malloc.

  // Allocate MAP block
  if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL) {
    printf("allocation error \n");
    exit (-1);
  }

  // Make sure pointer is on 4K boundary
  if ((unsigned long)gpio_mem % PAGE_SIZE)
    gpio_mem += PAGE_SIZE - ((unsigned long)gpio_mem % PAGE_SIZE);

  // Now map it
  gpio_map = (unsigned char *)mmap(
    (caddr_t)gpio_mem,
    BLOCK_SIZE,
    PROT_READ|PROT_WRITE,
    MAP_SHARED|MAP_FIXED,
    mem_fd,
    GPIO_BASE
    );

  if ((long)gpio_map < 0) {
    printf("mmap error %d\n", (int)gpio_map);
    exit (-1);
  }

[Klaus W. (mfgkw)]

Tip: mit MAP_ANONYMOUS | MAP_FIXED sowie einem fd=-1 kann man auch ohne 
zugehörige Datei mappen.
Siehe man mmap.

[Tobias W. (wagnertobse)]

Ok jetzt habe ich mmap ein bisschen mehr verstanden.
ich habe die zeile mit mmap() auf

virtual_base = mmap( NULL , 32, ( PROT_READ | PROT_WRITE ), MAP_SHARED, 
fd , 0x00010080 );

geändert. Jetzt gibt mit mmap den Fehler zurück :(
Der speicherbereich müsste durch den ersten Übergabewert, der jetzt NULL 
ist, den Speicherberich reservieren.

[CC (Gast)]

Tobias Wagner schrieb:
> Jetzt gibt mit mmap den Fehler zurück :(

Welchen Fehler denn?

[Tobias W. (wagnertobse)]

mmap gibt eine -1 zurück

[S. R. (svenska)]

Wenn mmap -1 zurückgibt, steht der Fehler in errno. Welchen Fehler 
bekommst du da? (Gleiche das am besten mit der Liste der möglichen 
Fehler aus der Manpage ab, z.B. http://linux.die.net/man/2/mmap ).

[mh (Gast)]

Warum möchte man auf eine fest vorgegebene virtuelle Adresse schreiben?

[Tobias W. (wagnertobse)]

In errno steht Invalid argument...
@mh
Ich möchte für eine Hardwareadresse eine Adresse in meinem virtuellen 
Adressraum.

[Tobias W. (wagnertobse)]

Ich habe vermutlich den Fehler gefunden :)
Ich habe den Flaschen speicherbereich für die Brücke gewählt.

[Klaus W. (mfgkw)]

1. Der Speicher wird immer ein Vielfaches einer Kachelgröße gemappt.
D.h. du wirst nicht irgendeine physikalische an irgendeine beliebige 
Adresse mappen können, sondern nur seitenweise.
Also erst überlegen, in welcher Seite die gesuchte Adresse ist, dann 
mappen.
2. Du musst entsprechend vorher für die gemappte Seite Speicher 
allokieren.
3. Siehe man mmap

[./. (Gast)]

Der TO scheint auch beratungsresistent zu sein.

Soll er mal allein weiter im trueben fischen...

[Tobias W. (wagnertobse)]

Es Funktioniert jetzt :)
Der Code sieht jetzt so aus:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <string.h>
#include "hwlib.h"
#include "socal/socal.h"
#include "socal/hps.h"
#include "socal/alt_gpio.h"
#include "system.h"



int main(){
  void *virtual_base;
  unsigned int offset = 0x00010080;

  unsigned int fd;
  unsigned int in = 0xFFFFFFFF;
  unsigned int out;
  unsigned int i = 0;
  off_t base = 0xff200000;



  if( ( fd = open( "/dev/mem", ( O_RDWR | O_SYNC ) ) ) == -1 ) {
    printf( "ERROR: could not open \"/dev/mem\"...\n" );
    return( 1 );
  }

  virtual_base = mmap( NULL , 2000000, PROT_WRITE , MAP_SHARED, fd , base );

  if( virtual_base == MAP_FAILED ) {
    printf( "ERROR: mmap() failed...\n" );
    close( fd );
    printf("%s\n", strerror(errno));
    return( 1 );
  }

  alt_write_word( virtual_base + offset, in );

  for(i = 0;i<=1000;i++){
    i--;
    i++;
  }
  out = alt_read_word(virtual_base);
  printf("%i wurde zurueckgegeben!!",out);
  return 0;
}

[Konrad S. (maybee)]

Klaus Wachtler schrieb:
> 2. Du musst entsprechend vorher für die gemappte Seite Speicher
> allokieren.

Ganz sicher nicht!

[Tock (Gast)]

/dev/mem oder /dev/kmem

[Florian H. (heeen)]

./. schrieb:
> Damit ein mmap Erfolg hat, muss etwas zum 'mmap'en da sein.
> Z.B. durch ein malloc.

Klaus Wachtler schrieb:
> 2. Du musst entsprechend vorher für die gemappte Seite Speicher
> allokieren.

Unsinn. Im Gegenteil verwenden einige Betriebssysteme mmap um Speicher 
für malloc zu alloziieren.

[Tobias W. (wagnertobse)]

So (Florian H.) habe ich es in den beschreibungen für malloc auch 
verstanden. Gibt man als ersten Übergabewert eine NULL an, wird ein 
freier Speicherbereich der angegeben Größe alloziiert.
Im Anhang befindet sich der Adressaufbau des Mikrocontrollers und ich 
kann mit meinen Programm mit den Lightweight FPGA Slaves kommunizieren 
(3 LEDs an der FPGA Peripherie einschalten).

[./. (Gast)]

> Unsinn. Im Gegenteil verwenden einige Betriebssysteme mmap um Speicher
> für malloc zu alloziieren.

mmap hat ja auch deutlich mehr als nur 1 Parameter.

Mein Schnipsel weiter oben funktionierte jedenfalls von Anfang an...
Du darfst das aber gerne weiter als Unsinn qualifizieren...

[Gsum (Gast)]

seek sollte auch auf /dev/mem funktionieren.

[Konrad S. (maybee)]

./. schrieb:
> Mein Schnipsel weiter oben funktionierte jedenfalls von Anfang an...
> Du darfst das aber gerne weiter als Unsinn qualifizieren...

... was noch lange nicht bedeutet, dass es notwendig ist.
Der mmap()-Aufruf überdeckt den von malloc() bereitgestellten Speicher. 
Kannst du machen, ist aber unnötig.

[Georg A. (georga)]

HW-IO via mmap ist bequem, geht aber nicht immer. x86 ist kein Problem, 
aber bei ARM muss das nicht immer gehen. Hab deshalb schon mal extra 
einen Treiber für ein paar Bits GPIO schreiben müssen...