Warum bekomme ich bei Beaglebone Black beim Zugriff auf GPIO2 und GPIO3 durch Kernelmodul einen Segmentierungsfehler?

Question

Ich habe versucht, Zugriff auf GPIO2 und GPIO3 auf dem Beaglebone Black über Kernel-Modul ohne Erfolg. Jedes Mal, wenn ich versuche, den GPIOs 2 und 3 einen Ausgabewert zuzuweisen, erhalte ich einen Segmentierungsfehler.

Der exakt gleiche Code (mit der entsprechenden Pinbelegung) funktioniert für GPIO0 und GPIO1.

Ich habe versucht, verschiedene Pins auf P8 und P9 im Zusammenhang mit GPIO2 und GPIO3 ohne Erfolg. Auf der anderen Seite funktioniert derselbe genaue Code für GPIO0 und GPIO1 mit entsprechender Pinbelegung.

Für Pin-Werte verwende ich das offizielle BBB-Handbuch. Für eine entsprechende E/A-GPIO Verfügbarkeit Ich bin Überprüfung dieses Diagramm von beagleboard.com:

#include <linux/init.h> 
#include <linux/module.h> 
#include <linux/kernel.h> 
#include <net/tcp.h> 

//Macros 
#define GPIO1_START_ADDR 0x4804C000 
#define GPIO2_START_ADDR 0x481AC000 
#define GPIO2_END_ADDR 0x481ACFFF 
#define GPIO3_START_ADDR 0x481AE000 

#define SIZE (GPIO2_END_ADDR - GPIO2_START_ADDR) 
#define GPIO_OE 0x134 
#define GPIO_DATAOUT 0x13C 

//A couple of standard descriptions 
MODULE_LICENSE("GPL"); 

static int hello_init(void) 
{ 
    volatile void *gpio_addr; 
    volatile unsigned int *oe_addr; 
    volatile unsigned int *dataout_addr; 

    printk(KERN_NOTICE "Module: Initializing module\n"); 

    printk(KERN_NOTICE "Module: Map GPIO\n"); 
    gpio_addr = ioremap(GPIO3_START_ADDR,SIZE); 

    printk(KERN_NOTICE "Module: Set oe_addr\n"); 
    oe_addr = gpio_addr + GPIO_OE; 

    printk(KERN_NOTICE "Module: Set dataout_addr\n"); 
    dataout_addr = gpio_addr + GPIO_DATAOUT; 

    //Code will work up to here for any GPIO. 
    //It crashes on the following for GPIO2 and GPIO3: 

    printk(KERN_NOTICE "Module: Set pin to OUTPUT\n"); 
    *oe_addr &= (0xFFFFFFFF^(1<<19)); 

    printk(KERN_NOTICE "Module: Set pin output to HIGH\n"); 
    *dataout_addr |= (1<<19); 

    return 0; 
} 

static void hello_exit(void) 
{ 
    printk(KERN_INFO "Exit module.\n"); 
} 

module_init(hello_init); 
module_exit(hello_exit); 

Wenn ich die beiden Linien *oe_addr &= (0xFFFFFFFF^(1<<19)); und *dataout_addr |= (1<<19); blockieren, läuft das Programm für alle GPIOs ohne Panne.

$uname -a: Linux beaglebone 3.8.13-bone79

Warum bin ich Segmentierungsfehler bekommen, wenn GPIO2 und GPIO3 zugreifen?

Answer 1

Nach viel Forschung habe ich ein paar nützliche Links wie this one und this one gefunden.

Es wird darauf hingewiesen, dass die Standardeinstellung für die GPIOs-Register 1, 2 und 3 Uhr deaktiviert ist, daher der Segmentierungsfehler beim Versuch, auf die Register zuzugreifen. Wenn das System einen GPIO zum Exportieren anfordert, ermöglicht es dann, dass der Takt und die GPIO-Register zur Verwendung verfügbar sind.

Um das Problem zu beheben, müssen wir die Uhren für diese GPIOs manuell aktivieren. Ich konnte dies nicht mit den Code-Beispielen in den Links tun.

jedoch unter Verwendung

echo 5 > /sys/class/gpio/export 
echo 65 > /sys/class/gpio/export 
echo 105 > /sys/class/gpio/export 

Bevor Sie die Mod Einfügen, ich habe Dinge gefunden richtig zu arbeiten. Durch Überwachen des Taktwerts an jedem GPIO habe ich festgestellt, dass sich der Wert von einem Wert zu "2" ändert. Die manuelle Eingabe von 2 in diese Werte reicht jedoch nicht aus, um die GPIOs zum Funktionieren zu bringen.

Wenn ich einen Weg finde, die Uhr durch Speicherkontrolle richtig zu aktivieren, werde ich diese Antwort aktualisieren.

Edit:

Nach mehr Getue und Forschung, die ich den Code bekommen haben, richtig zu arbeiten. Ich habe es als separates Modul geschrieben und es ist eingesetzt werden, bevor das Modul auf die Frage gestellt Einfügen:

#include <linux/init.h> 
#include <linux/module.h> 
#include <linux/kernel.h> 
#include <net/tcp.h> 

#define CM_PER_ADDR 0x44E00000 
#define CM_PER_SIZE 0x3FF 
#define CM_PER_GPIO1_ADDR 0xAC 
#define CM_PER_GPIO2_ADDR 0xB0 
#define CM_PER_GPIO3_ADDR 0xB4 

#define GPIO_COUNT 3 


//A couple of standard descriptions 
MODULE_LICENSE("GPL"); 

static int hello_init(void) 
{ 
    static volatile void* cm_per; 
    static volatile unsigned int* cm_per_gpio[GPIO_COUNT]; 

    static volatile int cm_per_addr[GPIO_COUNT] = {CM_PER_GPIO1_ADDR, CM_PER_GPIO2_ADDR, CM_PER_GPIO3_ADDR}; 

    static int i = 0; 

    printk(KERN_NOTICE "Module2: Initializing module\n"); 

    cm_per = ioremap(CM_PER_ADDR, CM_PER_SIZE); 
     if(!cm_per){ 
      printk (KERN_ERR "Error: Failed to map GM_PER.\n"); 
      return -1; //Break to avoid segfault 
     } 

    for(i = 0; i < GPIO_COUNT; i++){ 
     cm_per_gpio[i] = cm_per + cm_per_addr[i]; 

     //Check if clock is disabled 
     if(*cm_per_gpio[i] != 0x2){ 
     printk(KERN_NOTICE "Enabling clock on GPIO[%d] bank...\n", (i+1)); 
      *cm_per_gpio[i] = 0x2; //Enable clock 
      //Wait for enabled clock to be set 
      while(*cm_per_gpio[i] != 0x2){} 
     } 

     //Print hex value of clock 
     printk(KERN_NOTICE "cm_per_gpio[%d]: %04x\n", (i+1), *(cm_per_gpio[i])); 
    } 


    return 0; 
} 

static void hello_exit(void) 
{ 
    printk(KERN_INFO "Module: Exit module.\n"); //Print exit notice and exit without exploding anythin 
} 

module_init(hello_init); 
module_exit(hello_exit); 

Vom AM335x and AMIC110 Sitara™ ProcessorsTechnical Reference Manual, können wir sehen, wie CM_PER_GPIO # _CLKCTRL Register organisiert ist (wobei # repräsentiert die GPIO-Bank, die wir betrachten):

Tabelle 8-60. CM_PER_GPIO2_CLKCTRL Register Feldbeschreibungen

Es sagt uns auch, dass der Reset (default) Wert des Registers ist 30000h, CLOCK GESPERRT Bedeutung, was bedeutet, Modul deaktiviert.

Answer 2

Die Antwort, warum Ihr Code einen Segmentierungsfehler erhält, ist eigentlich irrelevant, weil er als Kernel-Modul fehlgeleitet ist, geworfen werden muss und Sie ihn neu schreiben müssen. Ihr Modul hat absolut keine Probleme, einen direkten Zugriff auf die "GPIO (Kontroll-) Register" zu erhalten, die bereits im Besitz des Pin-Control-Systems (pictrl) sind.

GPIO-Pins sind eine (generische) Ressource, die der Kernel verwaltet. Würden Sie einen Treiber schreiben, der gerade einen willkürlichen Speicherblock für seine Puffer verwendet?
Hoffentlich nicht, weil Speicher (eine andere) Ressource vom Kernel verwaltet wird.
Aber Ihr Modul ist nur mutwillig mit GPIO-Pins nach seiner eigenen Laune!

Die genaue Version des Linux-Kernels, die Sie verwenden, finden Sie im entsprechenden GPIO-Dokument: Documentation/gpio.txt for version 3.8.13.

Die verfügbaren Routinen, die das Modul verwenden können, gehören:

gpio_request() 
gpio_free() 

gpio_direction_input() 
gpio_direction_output() 

gpio_get_value() 
gpio_set_value() 

---

(BTW Code vernachlässigt den Rückgabewert von ioremap(), zu prüfen, welche null und dann wahrscheinlich führen könnte zu ein Segmentierungsfehler.)