#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include…
- User
#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h>
#include <linux/gpio.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/irq.h>
MODULE_AUTHOR("MGE"); MODULE_DESCRIPTION("A sample driver using interrupts"); MODULE_LICENSE("GPL");
// GPIO Bank 2 #define GPIO2_START_ADDR 0x481AC000 #define GPIO2_SIZE (0x481ADFFF - GPIO2_START_ADDR)
// CM_PER (Clock Module Peripheral Registers #define CM_PER_START_ADDR 0x44e00000 #define CM_PER_SIZE 0x400 #define CM_PER_GPIO2_CLKCTRL 0xb0
// GPIO memory-mapped register addresses. #define GPIO_IRQSTATUS_0 0x2C #define GPIO_IRQSTATUS_1 0x30 #define GPIO_RISINGDETECT 0x148 #define GPIO_FALLINGDETECT 0x14C
#define PIN_A_GPIO 68 // is on P9 pin 10 #define PIN_A_FLAGS GPIOF_IN #define PIN_A_LABEL "HI_PIN_A"
static irqreturn_t irq_handler_pin_a (int irq, void *dev_id) { printk (KERN_INFO "Hello from irq_handler_pin_a...\n");
return IRQ_HANDLED; }
static int __init hello_interrupts_start (void) { int retval, irq, regval; void __iomem *mem; void __iomem *cm_per; printk (KERN_INFO "Loading hello_interrupts module...\n");
/**
- Request the GPIO lines for the IRQ channels. */ retval = gpio_request_one(PIN_A_GPIO, PIN_A_FLAGS, PIN_A_LABEL);
if (retval) { printk (KERN_ERR "HI: Error: Failed to request GPIO pin#%i for IRQ (error %i)\n", PIN_A_GPIO, retval);
// return -retval; }
irq = gpio_to_irq (PIN_A_GPIO); if (irq < 0) { printk (KERN_ERR "HI: ERROR: Failed to obtain IRQ number for GPIO #%i (error %i)\n", PIN_A_GPIO, irq);
// return -irq; }
retval = request_irq (irq, irq_handler_pin_a, 0 /IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING/, PIN_A_LABEL, NULL); irq_set_irq_type (irq, IRQ_TYPE_EDGE_BOTH);
if (retval) { printk (KERN_ERR "HI: ERROR: The requested IRQ line#%i from GPIO#%i (error %i)\n", irq, PIN_A_GPIO, retval);
// return -retval; } else { printk (KERN_INFO "HI: Initialized GPIO #%i to IRQ #%i\n", PIN_A_GPIO, irq); }
/* Enable GPIO2 clock */ cm_per = ioremap(CM_PER_START_ADDR, CM_PER_SIZE); if(!cm_per) { printk (KERN_ERR "HI: ERROR: Failed to remap memory for CM_PER.\n"); return 0; } iowrite32(0x02, cm_per + CM_PER_GPIO2_CLKCTRL); iounmap(cm_per);
/**
- Setup the IRQ registers with the appropriate values. */ mem = ioremap(GPIO2_START_ADDR, GPIO2_SIZE); if(!mem) { printk (KERN_ERR "HI: ERROR: Failed to remap memory for GPIO Bank 2 IRQ pin configuration.\n"); return 0; }
// Enable the IRQ ability for GPIO_66. regval = ioread32 (mem + GPIO_IRQSTATUS_0); regval |= (1 << 2); iowrite32 (regval, mem + GPIO_IRQSTATUS_0);
regval = ioread32 (mem + GPIO_IRQSTATUS_1); regval |= (1 << 2); iowrite32 (regval, mem + GPIO_IRQSTATUS_1);
// Set GPIO_66 for rising and falling edge detection. regval = ioread32 (mem + GPIO_RISINGDETECT); regval |= (1 << 2); iowrite32(regval, mem + GPIO_RISINGDETECT);
regval = ioread32 (mem + GPIO_FALLINGDETECT); regval |= (1 << 2); iowrite32 (regval, mem + GPIO_FALLINGDETECT);
// Release the mapped memory. iounmap (mem);
return 0; }
static void __exit hello_interrupts_end(void) {
printk ("HI: Releasing IRQ resources...\n");
free_irq (gpio_to_irq (PIN_A_GPIO), NULL); gpio_free (PIN_A_GPIO);
printk (KERN_INFO "Goodbye hello_interrupts!\n"); }
module_init (hello_interrupts_start); module_exit (hello_interrupts_end); Na podstawie kodu
dodać obsługę przerwań zarówno dla przycisku podłączonego do GPIO68 (jest w kodzie) i GPIO69 (są to skrajne przyciski) Wynik pracy ma poprzez dmesg z rozróżnieniem który przycisk został naciśnięty
- Assistant
Aby dodać obsługę przerwań dla obu przycisków podłączonych do GPIO68 oraz GPIO69, musisz najpierw pamiętać o zapewnieniu odpowiedniego kodu zarządzania drugim przyciskiem. Oto proponowane kroki i szczegóły techniczne:
- Definicja parametrów drugiego przycisku: Podobnie jak dla GPIO68, zdefiniuj parametry dla GPIO69.
#define PIN_B_GPIO 69 #define PIN_B_FLAGS GPIOF_IN #define PIN_B_LABEL "HI_PIN_B"- Rejestracja i konfiguracja przerwania dla GPIO69:
Dodaj rejestrację dla GPIO69:
retval = gpio_request_one(PIN_B_GPIO, PIN_B_FLAGS, PIN_B_LABEL); if (retval) { printk(KERN_ERR "HI: Error: Failed to request GPIO pin#%i for IRQ (error %i)\n", PIN_B_GPIO, retval); // Jeśli niepowodzenie, mogą być konieczne dodatkowe akcje, naprawa lub zwolnienie zasobów. } irq = gpio_to_irq(PIN_B_GPIO); if (irq < 0) { printk(KERN_ERR "HI: ERROR: Failed to obtain IRQ number for GPIO #%i (error %i)\n", PIN_B_GPIO, irq); // Handle failure. } retval = request_irq(irq, irq_handler_pin_b, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, PIN_B_LABEL, NULL); if (retval) { printk(KERN_ERR "HI: ERROR: Failed to request IRQ line#%i from GPIO#%i (error %i)\n", irq, PIN_B_GPIO, retval); // Handle failure. } else { printk(KERN_INFO "HI: Initialized GPIO #%i to IRQ #%i\n", PIN_B_GPIO, irq); }- Implementacja obsługi przerwań dla obu przycisków:
Musisz zaimplementować funkcję
irq_handler_pin_baby móc obsłużyć przerwania dla GPIO69:static irqreturn_t irq_handler_pin_b(int irq, void *dev_id) { printk(KERN_INFO "Hello from irq_handler_pin_b...\n"); return IRQ_HANDLED; }- Konfiguracja wyprowadzeń dla GPIO_69 w rejestrach:
Podczas mapowania i konfiguracji rejestrów GPIO, upewnij się, że odpowiednio skonfigurowałeś rejestry dla obu GPIO68 i GPIO69. Zrób to analogicznie dla GPIO68.
- Zakończenie pracy modułu:
W funkcji
hello_interrupts_enddokonaj zwolnienia przerwań i GPIO dla obu pinów:free_irq(gpio_to_irq(PIN_A_GPIO), NULL); gpio_free(PIN_A_GPIO); free_irq(gpio_to_irq(PIN_B_GPIO), NULL); gpio_free(PIN_B_GPIO);Po wprowadzeniu tych zmian moduł sterownika kernela Linux będzie mógł rozróżniać naciśnięcia dla obu przycisków podłączonych do GPIO68 i GPIO69, logując odpowiednie informacje przez
printkco można później przeglądać za pomocądmesg. Remember to handle all errors appropriately, potentially freeing allocated resources and unregistering IRQs to avoid causing system instability. - User
napisz mi caly kod
- Assistant
Rozumiem! Oto pełny kod modułu jądra, który obsługuje przerwania dla GPIO68 i GPIO69 na platformie Linux:
#include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/gpio.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/irq.h> MODULE_AUTHOR("MGE"); MODULE_DESCRIPTION("A sample driver using interrupts for GPIO68 and GPIO69"); MODULE_LICENSE("GPL"); // GPIO Bank 2 #define GPIO2_START_ADDR 0x481AC000 #define GPIO2_SIZE (0x481ADFFF - GPIO2_START_ADDR) // CM_PER (Clock Module Peripheral Registers) #define CM_PER_START_ADDR 0x44e00000 #define CM_PER_SIZE 0x400 #define CM_PER_GPIO2_CLKCTRL 0xb0 // GPIO memory-mapped register addresses. #define GPIO_IRQSTATUS_0 0x2C #define GPIO_IRQSTATUS_1 0x30 #define GPIO_RISINGDETECT 0x148 #define GPIO_FALLINGDETECT 0x14C #define PIN_A_GPIO 68 // is on P9 pin 10 #define PIN_B_GPIO 69 // additional pin #define PIN_A_FLAGS GPIOF_IN #define PIN_B_FLAGS GPIOF_IN #define PIN_A_LABEL "HI_PIN_A" #define PIN_B_LABEL "HI_PIN_B" static irqreturn_t irq_handler_pin_a(int irq, void *dev_id) { printk(KERN_INFO "Interrupt triggered by GPIO68\n"); return IRQ_HANDLED; } static irqcan return_t irq_handler_pin_b(int irq, void *dev_id) { printk(KERN_INFO "Interrupt triggered by GPIO69\n"); return IRQ_HANDLED; } static int __init hello_interrupts_start(void) { int retval, irq_a, irq_b; void __iomem *mem; void __iomem *cm_per; printk(KERN_INFO "Loading hello_interrupts module...\n"); // Request GPIOs retval = gpio_request_one(PIN_A_GPIO, PIN_A_FLAGS, PIN_A_LABEL); if (retval) { printk(KERN_ERR "HI: Error: Failed to request GPIO pin#%i (error %i)\n", PIN_A_GPIO, retval); return retval; } retval = gpio_request_one(PIN_B_GPIO, PIN_B_FLAGS, PIN_B_LABEL); if (retval) { printk(KERN_ERR "HI: Error: Failed to request GPIO pin#%i (error %i)\n", PIN_B_GPIO, retval); return retval; } // Get IRQ numbers irq_a = gpio_to_irq(PIN_A_GPIO); irq_b = gpio_to_irq(PIN_B_GPIO); // Request IRQs retval = request_irq(irq_a, irq_handler_pin_a, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, PIN_A_LABEL, NULL); retval |= request_irq(irq_b, irq_handler_pin_b, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, PIN_B_LABEL, NULL); // Error checking if (retval) { printk(KERN_ERR "HI: ERROR: Cannot request IRQs (error %i)\n", retval); gpio_free(PIN_A_GPIO); gpio_free(PIN_B_GPIO); return retval; } // Enable clock for GPIO bank cm_per = ioremap(CM_PER_START_ADDR, CM_PER_SIZE); if (!cm_per) { printk(KERN_ERR "HI: ERROR: Failed to remap CM_PER\n"); free_irq(irq_a, NULL); free_irq(irq_b, NULL); gpio_free(PIN_A_GPIO); gpio_free(PIN_B_GPIO); return -ENOMEM; } iowrite32(0x02, cm_per + CM_PER_GPIO2_CLKCTRL); iounmap(cm_per); // Configure GPIO settings mem = ioremap(GPIO2_START_ADDR, GPIO2_SIZE); if (!mem) { printk(KERN_ERR "HI: ERROR: Failed to remap GPIO2\n"); free_irq(irq_a, NULL); free_irq(irq_b, NULL); gpio_free(PIN_A_GPIO); gpio_free(PIN_B_GPIO); return -ENOMEM; } // Set rising and falling edge detection for both pins printk(KERN_INFO "Configuring interrupt detection settings...\n"); iowrite32((1 << (PIN_A_GPIO % 32)) | (1 << (PIN_B_GPIO % 32)), mem + GPIO_RISINGDETECT); iowrite32((1 << (PIN_A_GPIO % 32)) | (1 << (PIN_B_GPIO % 32)), mem + GPIO_FALLINGDETECT); // Release mapped memory iounmap(mem); return 0; } static void __exit hello_interrupts_end(void) { free_irq(gpio_to_irq(PIN_A_GPIO), NULL); free_irq(gpio_to_irq(PIN_B_GPIO), NULL); gpio_free(PIN_A_GPIO); gpio_free(PIN_B_GPIO); printk(KERN_INFO "Goodbye from hello_interrupts module\n"); } module_init(hello_interrupts_start); module_exit(hello_interrupts_end);Ten kod przyjmuje, że oba GPIO mogą być skonfigurowane na te same wyzwalania przerwań. W przypadku różnych trybów dla obu pinów, niezbędne mogą być modyfikacje w konfiguracji pinów.
- User
a co chodzi z tym dmesg
- Assistant
Komenda
dmesg(skrót od "display message" czyli "wyświetl komunikat") jest narzędziem używanym w systemach Unixowych, takich jak Linux, do wyświetlania wiadomości z bufora pierścieniowego jądra. Pozwala na przeglądanie logów systemowych, szczególnie tych generowanych podczas uruchamiania systemu oraz przez sterowniki i inne komponenty systemu operacyjnego.W kontekście twojego modułu kernela, który używa funkcji
printkdo logowania,dmesgjest użyteczne do obserwacji odpowiedzi systemu na działanie modułu. Każde wywołanieprintk– jak np.:printk(KERN_INFO "Loading hello_interrupts module...\n");wysyła string do bufora logów jądra, skąd można go odczytać używając
dmesg. To sprawia, żedmesgjest kluczowym narzędziem przy debugowaniu sterowników i modułów jądra, gdyż umożliwia zrozumienie, co dzieje się w systemie 'pod maską'.Przykład użycia
dmesg:-
Załaduj moduł: Kiedy załadujesz swój moduł do kernela (np. za pomocą
insmod), można wykorzystaćdmesg, aby potwierdzić, że moduł został załadowany poprawnie:sudo insmod hello_interrupts.ko -
Sprawdź
dmesg:- Otwórz terminal i wpisz
dmesg | tail, aby zobaczyć ostatnie wiadomości z bufora jądra. Powinieneś zobaczyć komunikaty z twojego sterownika. - Możesz także użyć grepa do filtrowania specyficznych wiadomości:
dmesg | grep "hello_interrupts"To pokaże tylko te logi, które zawierają string "hello_interrupts".
- Otwórz terminal i wpisz
-
Dezinstalacja modułu: Po dezinstalowaniu modułu (
rmmod hello_interrupts) możesz ponownie śledzićdmesg, aby zobaczyć komunikaty o czyszczeniu zasobów i zwalnianiu IRQ, GPIO itp.
Dzięki temu,
dmesgstaje się niezwykle wartościowym narzędziem do monitorowania w czasie rzeczywistym jak system reaguje na działania sterownika, co jest szczególnie użyteczne podczas tworzenia i debugowania modułów jądra. -
- User
w sensie konkretnie napisz jak mam to uzyc w kontekscie zadania
- Assistant
W kontekście zadania polegającego na obsłudze przerwań dla GPIO68 i GPIO69 za pomocą modułu jądra Linux, wykorzystanie
dmesgjest bardzo wartościowe do sprawdzenia, czy logika przerwań działająca w sterowniku poprawnie reaguje na sygnały z tych pinów GPIO.Oto, jak możesz tego dokonać krok po kroku:
1. Kompilacja i ładowanie modułu
Po napisaniu kodu modułu i skompilowaniu go do pliku
.ko, załaduj go do jądra Linux za pomocą poleceniainsmod:sudo insmod hello_interrupts.ko2. Sprawdzenie logów za pomocą
dmesgPo załadowaniu modułu, użyj
dmesgw terminalu, aby zobaczyć logi kernela związane z załadowaniem i działaniem Twojego modułu:dmesg | grep "hello_interrupts"Wyszukasz w ten sposób wszystkie komunikaty, które zostały zalogowane przez twój moduł (dzięki użyciu
printkz prefiksem "HI:"), co pomoże Ci potwierdzić, że moduł został załadowany, i GPIO zostały poprawnie skonfigurowane.3. Testowanie działania przycisków
Jeśli masz fizyczny dostęp do hardware'u (np. Raspberry Pi, BeagleBone cz itp.), możesz teraz przetestować działanie przerwań, naciskając przyciski podłączone do GPIO68 i GPIO69.
4. Interpretacja wyników
Naciśnij przyciski kilka razy każdy, a następnie ponownie sprawdź
dmesg:dmesg | tailPowinieneś zobaczyć logi każdego przerwania, które zostało obsłużone przez twoje funkcje obsługi przerwań (
irq_handler_pin_aiirq_handler_pin_b), takie jakInterrupt triggered by GPIO68iInterrupt triggered by GPIO69. Dzięki temu możesz potwierdzić, które zdarzenia przerwania są generowane przez które przyciski.5. Dezinstalacja modułu
Gdy zakończysz testy, możesz usunąć moduł z jądra:
sudo rmmod hello_interruptsi ponownie sprawdzić
dmesg:dmesg | tailPowinieneś zobaczyć komunikaty o zwolnieniu zasobów modułu.
Zastosowanie
dmesgw praktyceZnakomicie sprawdza się do debugowania i weryfikacji zachowania urządzeń i sterowników. Jest nieoceniony, gdy chcesz wiedzieć, co się dzieje w systemie, szczególnie gdy pracujesz z niskopoziomowymi elementami systemu operacyjnego, takimi jak sterowniki urządzeń.