Interrupt i Linux/StrongArm 1100

Transkript

1 Interrupt i Linux/StrongArm 1100 Ett kapitel för kursen Wearable Computers D 10 p Namn: Handledare: Björne Lindberg och Ulf Brydsten

2 Innehållsförteckning Innehållsförteckning...2 Inledning...3 Interrupt...3 Linux interrupt API...3 Datastrukturen irq_desc_t...4 Status variabeln...5 Action listan...5 Depth...5 Lock...5 Datastrukturen hw_irq_controller...6 Typename...6 Startup...6 Shutdown...6 Enable...6 Disable...6 Ack...7 End...7 Set_affinity...7 do_irq() funktionen...7 handle_irq_event() funktionen eller do_irq()...7 Filen arch/arm/kernel/entry-armv.s...7 Filen arch/arm/mach-sa1100/irq.c...7 Filen include/asm-arm/arch-sa1100/irqs.h...7 Initiering av interrupthårdvara...8 SoftIRQ och tasklets...8 Interrupt probing...8 SA1100 processorns interrupt...10 Blockdiagram över interruptkontrollern på SA Interruptkontrollerns register...11 Interrupt pending register...11 IRQ pending reg. och FIQ pending reg...13 Mask register ICMR...13 Level register ICLR...14 Control register ICCR...14 Exempel på interrupt drivrutin för SA Drivrutinens funktionalitet...15 Keypad_init...15 Keypad_isr...15 Keypad_do_tasklet...15 mydev_read...15 Applikationens funktionalitet...16 Testkörningar...16 Källkod...17 irqdrv.c...17 Makefile för irqdrv...20 irqapp.c...20 Makefile för irqapp

3 Inledning Detta kapitel är ett delmoment i kursen Wearable Computers D, 10p. Kapitlet ger insikt i hur interrupt hanteras i Linux kärnan och de hårdvaruspecifika delarna av hanteringsprocessen beskrivs för StrongARM processorn SA1100. Kapitlet innehåller källkod för en exempeldrivrutin och en testapplikation, som utför tidmätning för olika delar i interrupthanteringsprocessen. Interrupt Ett interrupt är en signal som skickas till processorn från antingen hårdvara, hårdvaruavbrott, eller programvara, mjukvaruavbrott. Avbrottssignalen innebär en servicebegäran och medför normalt att processorn avbryter det den håller på med och exekverar en så kallad avbrottsrutin som är förutbestämd antingen i kärnan eller i användarens kod. Därefter återgår processorn att exekvera där den höll på då avbrottet skedde. Två olika typer av interrupt finns, interna och externa avbrott. Interna avbrott genereras av processorn själv, dessa används bland annat till att indikera att olika fel har uppstått så att programmeraren kan ta hand om dessa. Externa avbrott sker genom att en yttre enhet påverkar någon av processorns interrupt pinnar. Till externa avbrott räknas även interna timers. Linux interrupt API Linux interrupt API är den del av kärnan som arbetar mot hårdvarans (plattformens) interruptkontroller. Kunskap om interrupt APIn är nödvändig för att kunna porta Linux till en ny hårdvara, utan detta är det omöjligt att uppnå ett fungerande system. Vi börjar med att kolla närmare på de två viktigaste data strukturerna som används för att hantera interrupt i Linux kerneln, irq_desc_t och hw_irq_controller. För att klargöra en del saker kommer kod från Linux kerneln som körs på LART att användas, LART systemet bygger på en SA1100 processor och koden skiljer inte mycket från övriga SA1100 plattformers kod. Bilden nedan demonstrerar interrupthanteringssystemet i Linux. Bilden visar relationer mellan olika datastrukturer och funktioner. Punkterna nedan förklarar de olika stegen i bilden. Interrupt sker Asembler macrona i entry-armv.s exekveras därifrån anropas sedan C funktionen asm_do_irq() med hjälp av följande asembler instruktion bne asm_do_irq. asm_do_irq() funktionen körs, anropar do_irq() funktionen. do_irq() anropar i sin tur do_irq(). do_irq() funktionen anropar varje funktion som ska hantera interruptet, dvs. alla irqaction strukturer loopas genom och varje irqaction.handler exekveras. När exekveringen återgår till asm_do_irq() så exekveras alla väntande interrupt på samma sätt. Slutligen anropas do_softirq() funktionen. 3

4 Datastrukturen irq_desc_t Grundstenen i Linux inerrupthantering är denna datastruktur. En array av denna struktur som heter irq_desc[] håller koll på källan till varje interrupt i Linux. Nedan visas definitionen för irq_desc_t, koden är tagen från include/linux/irq.h i kernelns källkod. /* * This is the "IRQ descriptor", which contains various information * about the irq, including what kind of hardware handling it has, * whether it is disabled etc etc. * * Pad this out to 32 bytes for cache and indexing reasons. */ typedef struct unsigned int status; /* IRQ status */ hw_irq_controller *handler; struct irqaction *action; /* IRQ action list */ unsigned int depth; /* nested irq disables */ spinlock_t lock; cacheline_aligned irq_desc_t; 4

5 Status variabeln Status fältet anger som namnet säger, interruptkällans status. Status kan vara en kombination av ett eller flera av nedanstående bitmönster. En del av dessa statusbitmönster har endast betydelse i en SMP arkitektur, dvs. en multiprocessorarkitektur. Status bitmönster IRQ_INPROGRESS - Interruptet hanteras. IRQ_DISABLED - Interruptet är inte aktiverat. IRQ_PENDING - Interruptet väntar, och bör hanteras. IRQ_REPLAY - Interruptet har mottagits men inte ännu bekräftats. IRQ_AUTODETECT - Håller på med automatisk sökning efter interruptkällan. IRQ_WAITING - Väntar på interrupt från källan, används vid autodetect. IRQ_LEVEL - Interrupt "triggas" på hög/låg flank. IRQ_MASKED - Interruptet är maskerat och är inte vara aktivt. IRQ_PER_CPU - Interruptet har tilldelats en viss CPU, endast vid SMP. Action listan Aktion fältet är en länkad lista med irqaction datastrukturer. Varje struktur i listan håller reda på minnesadressen till interrupthanteringsfunktionen. En ny irqaction struktur läggs till i listan varje gång request_irq() funktionen anropas. Nedan visas hela datastrukturen irqaction, koden tagen från filen include/linux/interrupt.h struct irqaction void (*handler)(int, void *, struct pt_regs *); unsigned long flags; unsigned long mask; const char *name; void *dev_id; struct irqaction *next; ; Fältet irq.handler pekar på den funktion som ska exekveras då ett visst hårdvaruinterrupt sker, och har ingen som helst vetskap om varför eller vad som gjorde att interruptet skedde. Detta gör att ineterruptdrivna drivrutiner är mycket enkla att porta mellan olika arkitekturer. Depth Detta fält har uppkommit på grund av att en del systems interruptkontrollers inte gillar upprepade enable/disable av interrupt eller att dessa sker i obalans. Så depth fältet håller alltså reda på enable/disable anrop av ett visst interrupt och ser till att dessa hålls i balans. Lock Detta fält har betydelse i multiprocessor system och kan alltså låsa strukturen så den inte behandlas av flera processorer. 5

6 Datastrukturen hw_irq_controller Varje interruptbeskrivning i irq_desc_t innehåller fältet handler, detta fält refererar till en hw_irq_controller struktur. Definitionen av hw_irq_controller strukturen finns i filen include/linux/irq.h och visas här nedanför. /* * Interrupt controller descriptor. This is all we need * to describe about the low-level hardware. */ struct hw_interrupt_type const char * typename; unsigned int (*startup)(unsigned int irq); void (*shutdown)(unsigned int irq); void (*enable)(unsigned int irq); void (*disable)(unsigned int irq); void (*ack)(unsigned int irq); void (*end)(unsigned int irq); void (*set_affinity)(unsigned int irq, unsigned long mask); ; typedef struct hw_interrupt_type hw_irq_controller; Typename Fältet typename innehåller en kort namnbeskrivning av arkitekturens interruptkontroller, detta textfält används i bl.a. Linux /proc katalogen för att visa kontrollerspecifik information. Startup Kerneln anropar kontrollerns startup() funktion då en drivrutin gör förfrågan efter ett visst interrupt via funktionen request_irq() eller när interrupt initieras med autodetect. Startup() är rent funktionellt identisk med enable-funktionen förutom att startup tar bort eventuella köande/väntande interrupt, medan enable inte gör det. I inbyggda Linuxssystem som har en interruptkontroller som inte köar upp interrupt så är startup() och enable() funktionerna samma i drivrutinen för systemets interruptkontroller. Shutdown Precis som namnet säger så stänger denna funktion ner ett interrupt i interruptkontrollern. Funktionen anropas även då en drivrutin gör free_irq(). Shutdown funktionen är ofta samma funktion som disable() funktionen. Enable Denna funktion informerar systemets interruptkontroller om att aktivera den efterfrågade interruptkanalen. Disable Funktionen informerar systemets interruptkontroller att inaktivera ett visst interrupt. 6

7 Ack Kerneln anropar interrupkontrollerns ack() funktionen genast ett interrupt dyker upp, före detta behandlas. Vissa kontroller använder sig inte av denna funktion medan en del andra mappar ack() funktionen till disable(), så att inte ett nytt interrupt kan ske på samma kanal innan det föregående har behandlats. End När kerneln har behandlat ett interrupt anropas denna funktion i interruptkontrollerns drivrutin, kontrollern förväntas därmed ställa in sig så att nya interrupt kan ske på kanalen. Precis som i föregående funktion mappas denna funktion ibland till enable() av samma orsak. Set_affinity I SMP arkitekturer används denna funktion till att bestämma vilken CPU som ska behandla interruptet. Funktionen används inte i enprocessorsystem. do_irq() funktionen Linuxkärnans inblandning i interrupt- och undantagshanteringen börjar i och med denna funktion, som anropas via processorns interrupt request handler. Källkoden för do_irq() funktionen på SA1100 systemet finns i filen arch/arm/kernel/irq.c Normalt är det väldigt små skillnader i olika arkitekturers do_irq() funktion, för i stort sett manipuleras endast irq_desc_t strukturer i funktionen. Den riktiga hanteringen av interrupt sker i funktionen handle_irq_event() som i SA1100 arkitekturen har fått namnet do_irq(). handle_irq_event() funktionen eller do_irq() Då do_irq() funktionen har identifierat interruptet skickas listan med interrupthanteringsfunktioner till denna funktion, för vidare behandling. Härifrån anropas varje interrupthanteringsfunktion för alla interrupt som ska behandlas. Med andra ord funktionerna som har skrivits för interrupthantering i drivrutiner för en viss hårdvara. Exempel på detta visas i källkoden till exempeldrivrutinen längre fram i kapitlet. Filen arch/arm/kernel/entry-armv.s I denna fil finns maskinspecifika interruptfunktioner. Koden i denna fil är skriven i assembler och här läses av vilka interrupt som har skett varvid C funktionen asm_do_irq() anropas som i sin tur sedan anropar do_irq. Filen arch/arm/mach-sa1100/irq.c I denna fil finns bland annat funktionen SA1100_init_irq(), funktionen initierar hårdvarans interruptkontroller. I filen finns också funktionerna mask_irq() och unmask_irq() mfl. Filen include/asm-arm/arch-sa1100/irqs.h I denna fil definieras alla IRQ nummer för samtliga interrupt på SA1100 processorn. 7

8 Initiering av interrupthårdvara Kerneln initierar interruptkontrollerns hårdvara genom funktionen init_irq() som anropas från funktionen start_kernel(). Implementationen av init_irq() finns alltid i de arkitekturspecifika delarna av kernel koden, för SA1100 finns funktionen i filen arch/arm/mach-sa1100/irq.c. Och start_kernel() finns i init/main.c SoftIRQ och tasklets Softirq körs skilt från hårdvaruinterrupt i Linux kärnan. Softirq fungerar så länge interrupt är aktiverat i systemet, softirq ersätter bottom-half strategin som användes i äldre linux kärnor (2.2), vilket inte kommer att behandlas i detta kapitel. Softirq körs på varje processor i systemet om det är ett multiprocessorsystem. Tasklet är som ett softirq, förutom att detta körs enbart på en processor, även om systemet tillhandahåller fler. Ordet tasklet är aningen vilseledande eftersom detta inte har något med aktiva processer i operativssytemet att göra. Exempel på tasklet visas i exempeldrivrutinen längre fram i kapitlet. Softirq och tasklets är implemnterad i kärnan med sina egna datastrukturer och funktioner, och är i princip helt hårdvaruoberoende så länge kernelns do_irq() funktion anropar do_softirq() funktionen, detta görs i ARM arkitekturen. Aktiva softirq och tasklets hanteras av ksoftirqd tråden. Interrupt probing Linux kärnan tillhandahåller funktioner för interrupt probing, dvs automatikst avgöra vilken interrupt kanal en viss hårdvara är bunden till. Denna funktionalitet kan användas av drivrutiner via funktionerna probe_irq_on() och probe_irq_off(). När en drivrutin ska söka efter interrupt kanalen anropas först probe_irq_on() för att meddela kerneln om att probing ska inledas. Sedan anropar drivrutinen något i hårdvaran som "tvingar" den att ge ifrån sig ett interrupt. Och slutligen anropas probe_irq_off() vilken returnerar interruptkanalen som används för hårdvaran. 8

9 Kodexempel med IRQ probing: void mydrvprobeirq() unsigned long mask; int irq, retry=5; while (retry--) mask = probe_irq_on(); /* Gör något med hårdvaran som tvingar den att ge ifrån sig ett interrupt */ irq = probe_irq_off(mask); if (irq <= 0) printk(kern_info ": Could not find interrupt line."); else printk(kern_info ": Found interrupt line %d", irq); if (irq > 0) if (request_irq(irq, &my_isr, SA_INTERRUPT, "my_isr", NULL)) else printk(kern_info ": Bind IRQ error"); printk(kern_info ": Bind IRQ done"); break; 9

10 SA1100 processorns interrupt SA1100 processorns interruptkontroller makserar alla interrupt oavsett om dessa är FIQ (Fast IRQ) eller IRQ interrupt och kombinerar dessa till. Interrupthanteringen i SA1100 är indelad i två delar. Lägsta nivån av hanteringsprocessen representeras av interruptkontrollerns IRQ pending register (ICIP) och FIQ pending registret (ICFP), dessa register innehåller alla aktiverade och omaskerade interruptkällor. Interrupten som är aktiverade i sin hårdvara görs synliga via interruptkontrollerns mask register (ICMR). ICIP registret innehåller alla interrupt som är programmerade att generera ett IRQ avbrott och ICFP innehåller alla FIQ avbrott som har aktiverats. Valet av ICIP eller ICFP sköts genom att programmera registret ICLR level register. Andra nivån av hanteringsprocessen är egentligen hårdvaran som genererar interrupten. Normalt så kombineras flera interrupt från denna nivå (genom en ELLER procedur) och skickas vidare till första nivån. Vanligtvis kan källan till interruptet avläsas via två register, ICIP eller ICFP beroende på vilken interrupthanterare som körs i mjukvaran (Linux kerneln) för tillfället. När processorn är i idle mode så kommer varje interrupt att väcka upp den igen, interrupt mask registret ignoreras när systemet är idle. Blockdiagram över interruptkontrollern på SA

11 Interruptkontrollerns register SA1100 processorns interruptkontroller består av fyra olika register. ICIP, IRQ pending register. ICFP, FIQ pending register. ICMR, Mask register. ICLR, Level register, väljer IRQ eller FIQ. Vid reset av processorn så inaktiveras ICIP och ICFP registren och de övriga har okänt innehåll, alltså måste interruptkontrollern initieras. Interrupt pending register ICPR är ett 32-bitars läsbart register som visar alla aktiva interrupt i systemet. Dessa bitar påverkas inte av mask registret (ICMR). Nedanstående tabell visar alla fält i registret, samt deras interruptkälla och andra nivåns källa. 11

12 Som man kan se i tabellen så har flera fält i detta register fler än en interruptsignal. När ett interrupt kommer från en av dessa kan interrupthanteringsrutinen avläsa vilken enhet som gav upphov till interruptet, men inte den exakta källan. För att få fram exakta källan måste rutinen läsa av enhetens status och därifrån avgöra vad som ledde till interrupt. För alla interrupt som bara har en källa kan dessa avläsas direkt. 12

13 IRQ pending reg. och FIQ pending reg. ICIP och ICFP innehåller en flagga per interrupt, totalt 32, som indikerar att ett interrupt har skett. I interruptrutinerna läses ICIP och ICFP av för att avgöra vilket/vilka interrupt som skett. Bitarna är endast läsbara. Tabellerna nedan visar ICIP- respektive ICFP bitarnas placeringar i registren. Mask register ICMR ICMR registret innehåller en maskbit för varje interrupt som väntar, maskbiten kontrollerar om det väntande interruptet ska generera ett processor interrupt eller om det ska ignoreras. När ett väntande interrupt aktiveras sänds det till processorn endast om motsvarande bit i ICMR är satt till en 1:a. Om processorn är i idle-mode så ignoreras masken helt och hållet. Maskbitarna är främst till nytta då systemet vill ha prioritet på interrupten, då kan ett interrupt av lägre prioritet maskas bort ifall interrupt av högre prioritet ännu inte har behandlats. 13

14 Level register ICLR ICLR registret styr om interruptet ska behnadlas som IRQ eller FIQ (Fast IRQ, detta används mycket sällan och funkar inte speciellt bra i Linux). Om ett väntande interrupt är omaskerat så läses motsvarande ICLR bit av för att avgöra vilket sorts interrupt som ska genereras. ICLR bitarna har ingen betydelse för maskerade interrupt. Control register ICCR ICCR registret innehåller endast en kontrollbit, disable idle mask bit (DIM). Om denna bit är satt till en 1:a förhindrar den att alla interrupt kan väcka processorn ur idle mode. Istället kan endast de interrupt som inte är maskerade väcka processorn. 14

15 Exempel på interrupt drivrutin för SA1100 Detta kodexempel illustrerar hur interrupt används i en linuxdrivrutin för SA1100 processorn. Drivrutinen använder sig av IRQ_GPIO9, vilket är interruptet som kan genereras på GPIO pinne nummer 9. Valet av just denna pinne var endast på grund av att den var den första lediga pinnen på mitt system just nu. Alltså det går lika bra att byta ut denna till någon av IRQ pinnarna. Många namn i drivrutinen har inget att göra med drivrutinens uppgift, detta på grund av att jag har modifierat en drivrutin för knapparna som jag redan hade skrivit. För att kunna köra denna drivrutin måste ett en device skapas i /dev katalogen på SA1100 systemet. På LART systemet görs detta t.ex. på följande sätt. Mounta en färdig ramdisk på värddatorn genom följande kommando mount o loop rdisk /mnt/rd Skapa en ny device på ramdisken med major-nummer 43 och namnet keypad. mknod /mnt/rd/dev/keypad c 43 0 Kopiera in den kompilerade drivrutinen irqdrv.o och applikationen irqapp till ramdisken. Umounta ramdisken, packa ihop den och skicka den till LART systemet. Drivrutinens funktionalitet Denna drivrutin har till uppgift att mäta hur lång tid det tar från det att ett interrupt har kommit till interrupthanteringsfunktionen tills det att den når applikationen som använder drivrutinen. Keypad_init Drivrutinen fungerar så att när den laddas in i systemet, med kommandot insmod irqdrv.o så körs funktionen keypad_init(). Denna funktion registrerar devicen /dev/keypad och kopplar filoperationerna till den. Sedan ställer drivrutinen in GPIO_GPIO9 att trigga på fallande flank med hjälp av funktionen set_gpio_irq_edge efter det görs en förfrågan om att få IRQ kanal IRQ_GPIO9. Och funktionen keypad_isr kopplas som interrupthanteringsfunktion. Keypad_isr Denna funktion kommer nu att exekvera så fort GPIO9 går låg i den här funktionen skrivs nuvarande tid ut i sekunder och mikrosekunder, samt antalet interrupt. I funktionen scheduleras en tasklet funktion som ska köras så fort den får tid. Keypad_do_tasklet Tasklet funktionen gör samma sak som interrupthanteraren, alltså skriver ut tiden. Så att man kan se skillnaden i tid mellan dessa två funktioner. Dessutom säger den till läskön att väckas upp med funktionen wake_up_interruptible(&keypad_queue); mydev_read Denna funktion körs så fort applikationen försöker läsa från drivrutinen. Men i funktionen sätts den att sova tills den väcks upp av ett interrupt på GPIO9, detta görs med hjälp av denna funktion interruptible_sleep_on(&keypad_queue); Och i detta exempel skrivs bara en 1:a till applikationen då den väcks upp av interrupt. 15

16 Applikationens funktionalitet Denna applikation är mycket enkel och använder sig alltså av devicen /dev/keypad för att kommunicera med drivrutinen. Då applikationen körs öppnas /dev/keypad för läsning. Sedan anropas funktionen read för att läsa från drivrutinen. Eftersom drivrutinen använder interruptible sleep så väntar applikationen tills drivrutinen väcks upp av ett interrupt. Då läsningen är klar skriver applikationen ut tiden, som nu kan jämföras mot tiderna från drivrutinen och totala fördröjningen kan räknas ut. Testkörningar Ladda drivrutinen insmod irqdrv.o Using irqdrv.o keypad initializing driver... (Följande utskrifter är modifieringar i kerneln (hacks) för att se vad som händer, alltså inget som visas normalt med standard kärna.) irq: 0 gpio_mask: 512. irq: 1 gpio_mask: 256. irq: 2 gpio_mask: 128. irq: 3 gpio_mask: 64. irq: 4 gpio_mask: 32. irq: 5 gpio_mask: 16. irq: 6 gpio_mask: 8. irq: 7 gpio_mask: 4. irq: 8 gpio_mask: 2. irq: 9 gpio_mask: 1. irg_desc[9] is now valid. irq Request IRQ returned 0 drv: Bind IRQ done [[[root@mp3machine:~]]] Generera interrupt på GPIO9 time value in keypad_isr : interrupt count in keypad_isr : 1 time value in keypad_do_tasklet : interrupt count in keypad_do_tasklet : 1 time value in keypad_isr : interrupt count in keypad_isr : 2 time value in keypad_do_tasklet : interrupt count in keypad_do_tasklet : 2 time value in keypad_isr : Starta applikationen och generera interrupt [[[root@mp3machine:~]]]./irqapp opened keypad app opened /dev/keypad time value in keypad_isr : interrupt count in keypad_isr : 6 time value in keypad_do_tasklet : interrupt count in keypad_do_tasklet : 6 time value in app : released keypad [[[root@mp3machine:~]]] 16

17 Källkod irqdrv.c #if defined(config_modversions) #define MODVERSION #include <linux/modversions.h> #endif #include <linux/config.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/slab.h> #include <asm/segment.h> #include <asm/uaccess.h> #include <asm/hardware.h> #include <linux/fs.h> #include <asm/delay.h> #include <asm/irq.h> #include <linux/sched.h> #include <linux/mm.h> #include <linux/sysctl.h> #include <linux/timer.h> #include <linux/tqueue.h> #include <linux/interrupt.h> #define DRIVER_NAME "keypad" #define MYDEV_MAJOR 43 long interrupt_cnt = 0; */ /*A global variable for counting interrupts, /* MyDEV File operations*/ static int mydev_open(struct inode *inode, struct file *filp); static int mydev_release(struct inode *inode, struct file *filp); static ssize_t mydev_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos); static ssize_t mydev_read(struct file *filp, char *buf, size_t count, loff_t *f_pos); static int mydev_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg); static void keypad_isr(int irq, void *dev_id, struct pt_regs *regs); void keypad_do_tasklet(unsigned long unused); DECLARE_TASKLET(keypad_tasklet, keypad_do_tasklet, 0); /*The tasklet list we put our*/ DECLARE_WAIT_QUEUE_HEAD(keypad_queue); /*The queue we put read to sleep in*/ static struct file_operations mydev_fops = read: mydev_read, write: mydev_write, ioctl: mydev_ioctl, open: mydev_open, release: mydev_release, ; 17

18 static int mydev_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) // Nothing here... return 0; static ssize_t mydev_read(struct file *filp, char *buf, size_t count, loff_t *f_pos) int retvalue; unsigned char *kbuf, *ptr; retvalue = count; /*Sleeps until next interrupt wakes it*/ interruptible_sleep_on(&keypad_queue); kbuf = kmalloc(count, GFP_KERNEL); if (!kbuf) return -ENOMEM; ptr = kbuf; // Just return 1 when app is reading. *ptr = 1; copy_to_user(buf, kbuf, retvalue); kfree(kbuf); return retvalue; static ssize_t mydev_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos) int retvalue = count; unsigned char *kbuf; kbuf = kmalloc(count, GFP_KERNEL); if (!kbuf) return -ENOMEM; if(copy_from_user(kbuf, buf, count)) return -EINVAL; printk("<1>recieved %d elements\n", count); kfree(kbuf); return retvalue; static int mydev_open(struct inode *inode, struct file *filp) MOD_INC_USE_COUNT; printk("<1>opened keypad\n"); return 0; static int mydev_release(struct inode *inode, struct file *filp) 18

19 MOD_DEC_USE_COUNT; printk("<1>released keypad\n"); return 0; int keypad_init() int result; printk(driver_name " initializing driver...\n"); result = register_chrdev(mydev_major, "keypad", &mydev_fops); if (result < 0) printk("<1>keypad: can't get major nr\n"); return result; // Interrupt /* Enable GPIO as interrupt line */ GPDR &= ~GPIO_GPIO9; set_gpio_irq_edge(gpio_gpio9, GPIO_FALLING_EDGE); // Allocate the IRQ result = request_irq(irq_gpio9, &keypad_isr, SA_INTERRUPT, "keypad_int", NULL); printk(kern_info " Request IRQ returned %d\n", result); if (result) printk(kern_info ": Bind IRQ error\n"); else printk(kern_info ": Bind IRQ done\n"); return 0; void keypad_cleanup() free_irq(irq_gpio9, NULL); printk(driver_name " cleaning up...\n"); unregister_chrdev(mydev_major, "keypad"); static void keypad_isr(int irq, void *dev_id, struct pt_regs *regs) struct timeval tv; do_gettimeofday(&tv); printk(kern_info "time value in keypad_isr : %ld.%ld\n", tv.tv_sec, tv.tv_usec); tasklet_schedule(&keypad_tasklet); interrupt_cnt++; printk(kern_info "interrupt count in keypad_isr : %ld\n", interrupt_cnt); 19

20 void keypad_do_tasklet(unsigned long unused) struct timeval tv; wake_up_interruptible(&keypad_queue); do_gettimeofday(&tv); printk(kern_info "time value in keypad_do_tasklet : %ld.%ld\n", tv.tv_sec, tv.tv_usec); printk(kern_info "interrupt count in keypad_do_tasklet : %ld\n", interrupt_cnt); module_exit(keypad_cleanup); module_init(keypad_init); Makefile för irqdrv TARGET = arm-linux- CC = $(TARGET)gcc LD = $(TARGET)ld NM = $(TARGET)nm INCLUDE = /home/pontus/stuff/lart/linux/include CFLAGS =-c -Wall -O2 -D KERNEL -DMODULE -I$(INCLUDE) LFLAGS = all: irqdrv.o $(NM) lcd.o >./syms clean: rm irqdrv.o rm syms irqdrv.o: irqdrv.c $(CC) $(CFLAGS) irqdrv.c -o irqdrv.o irqapp.c #include <stdio.h> #include <fcntl.h> #include <unistd.h> #include <sys/ioctl.h> #include <string.h> #include <sys/time.h> int main(int argc, char *argv[]) char key; struct timeval tv; struct timezone tz; int fd = open("/dev/keypad", O_RDWR); if(fd == -1) perror("open"); 20

21 return 1; printf("app opened /dev/keypad\n"); read(fd, &key, 1); gettimeofday(&tv, &tz); printf("time value in app : %ld.%ld\n", tv.tv_sec, tv.tv_usec); close(fd); return 0; Makefile för irqapp CC = arm-linux-gcc CFLAGS = -g -O2 -Wall BIN = irqapp OBJS = irqapp.o HEADERS = all: $(BIN) $(BIN): $(OBJS) $(CC) $(OBJS) -o $(BIN) $(OBJS): %.o: %.c $(HEADERS) $(CC) $(CFLAGS) -c $< -o $@ #install: # install $(bin) /usr/bin clean: rm -f $(OBJS) $(BIN) *~ core 21