SWI Handler erklärung?

mehr ist leider in dieser File nicht an code drinnen !?

Oberfläche :Ubuntu
Tools:
Snavigator
 (terminalersatz)

In der Aufgabe soll ein SWI Handler genutzt werden, um eine Trennung des 
Low Level
IOs vom Anwendungsprogramm zu erreichen. Dazu sind die Funktionen die 
den SWInterrupt
aufrufen in Assembler zu implementieren und mit dem Debugger ist die
Funktionsweise des
Interrupthandlers zu untersuchen.

Es sollen die Funktion puts (siehe ser_io.S) in Assembler so ergänzen, 
dass auch der
String auf die serielle Schnittstelle ausgegeben wird. Die IO-Funktionen 
putchar und
getchar (siehe seriell.S) werden dabei über einen SWI (siehe swi.S) 
aufgerufen.
void puts(char *) Ausgabe eines nullterminierten Strings und Ersetzung 
von Newline
durch Carriage Return (0x0d) und Linefeed (0x0a).

Nun ist der Code des SWI-Handlers zu erklären ?????? :-))) (siehe 
swi.S).

3 dateien sind beinhaltet : oben genannte swi.s
+ 2 folgende

hoffe es hilft ein bischen weiter


___________
@----------------------------------------------------------------------- 
-----
@ File Name           : ser_io.S
@ Object              : Ein- Ausgabe-Funktionen der seriellen 
Schnittstelle
@----------------------------------------------------------------------- 
-----

@ Debuginformationen
  .file  "ser_io.S"

@ Funktion
  .text
  .align  2
  .global  inits
  .type  inits,function
inits:
  stmfd sp!,{lr}  @ Retten der Register
  swi 0
  ldmfd sp!,{pc}  @ Rücksprung

@ Funktion
  .text
  .align  2
  .global  puts
  .type  puts,function
puts:
  stmfd sp!,{lr}  @ Retten der Register

// Hier muß Ihr Code eingefügt werden.

  mov r1,r0

puts_start:


  ldrb r0,[r1],#1
  cmp r0,#0
  beq puts_end

// /n /r

  cmp r0,#0x0a
  moveq r0,#0x0d

  swieq 1

  moveq r0,#0x0a


  bl putchar
  b puts_start

puts_end:

  ldmfd sp!,{pc}  @ Rücksprung

@ Funktion
  .text
  .align  2
  .global  gets
  .type  gets,function
gets:
  stmfd  sp!,{lr}  @ Retten der Register

// Hier könnte Ihr Code eingefügt werden!

  ldmfd sp!,{pc}  @ Rücksprung

.end

-----------------
@----------------------------------------------------------------------- 
-----
@ File Name            : seriell.S
@ Object              : Grundfunktionen der seriellen Schnittstelle
@----------------------------------------------------------------------- 
-----

  .file  "seriell.S"

#include "../h/pmc.inc"
#include "../h/pio.inc"
#include "../h/usart.inc"

DEFAULT_BAUD = 38400
CLOCK_SPEED = 25000000
US_BAUD =  0x29  @ CLOCK_SPEED / (16*(DEFAULT_BAUD))

@ Funktion
  .text
  .align  2
  .global  init_ser
  .type  init_ser,function
init_ser:
  stmfd    sp!, {r0-r3, lr}    @ Register retten
  adr      r0,L1
  adr      r1,L1_end
init_ser_loop:
  ldmia    r0!, {r2-r3}
  cmp      r0, r1
  str      r3, [r2]
  bne      init_ser_loop
  ldmfd    sp!, {r0-r3, pc}    @ Rücksprung
L1:
  .word  PMC_BASE+PMC_PCER, 0x4
  .word  PIOA_BASE+PIO_PDR, 0x18000
  .word  USART0_BASE+US_CR, 0xa0
  .word  USART0_BASE+US_MR, 0x8c0
  .word  USART0_BASE+US_BRGR, US_BAUD
  .word  USART0_BASE+US_CR, 0x50
L1_end:

@ Funktion
  .text
  .align  2
  .global  putchar
  .type  putchar,function
putchar:
  stmfd    sp!, {r0-r2, lr}    @ Register retten
  ldr      r2, =USART0_BASE
1:
  ldr      r1, [r2, #US_CSR]
  tst      r1, #US_TXRDY  @ ist Transmitter frei
  beq      1b
  str      r0, [r2,#US_THR]
  ldmfd    sp!, {r0-r2, pc}    @ Rücksprung

@ Funktion
  .text
  .align  2
  .global  getchar
  .type  getchar,function
getchar:
  stmfd    sp!, {r1, r2, lr}    @ Register retten
  ldr      r2, =USART0_BASE

1:
  ldr      r1, [r2, #US_CSR]
  ands    r1, r1, #US_RXRDY
  beq      1b
  ldr      r0, [r2, #US_RHR]
  ldmfd    sp!, {r1, r2, pc}    @ Rücksprung

.end

Moin, also SWIs sind 'ne Möglichkeit anderen Programmen Funktionen von 
dem Code der die Interrupts verwaltet zugänglich zu machen. Ich hab' 
z.B. 'n Bootloader geschrieben der gleichzeitig auch eine Interrupt 
getriebene serielle USB Schnitstelle bereitstellt. Damit dann das 
Programm, das hochgeladen wird nicht den ganzen Interrupt code und den 
für USB CDC/ACM nochmal beinhalten muss mache ich dann die putc, getc, 
... via SWIs sichtbar.

  ldr      sp, STACK             <- setzt den Stack Pointer auf Adresse 
STACK
  stmfd    sp!, {lr}             <- wirft die ReturnAddr. auf den Stack
  ldr      ip,[r14, #-4]         <- holt den auslösenden SWI opcode
  bic      ip, ip, #0xff000000   <- extrahiert SWI Nummer
  mov      ip, ip, lsl #2
  ldr      lr, =SWIJumpTable      ablegen
  ldr      ip, [lr, ip]          <- lädt SWI-Fkt. Adresse
  mov      lr, pc
  mov      pc, ip                <- ruft SWI-Fkt auf
  ldmfd    sp!, {pc}^            <- return;