Inline Assembler _crc_ccitt_update von util/crc16.h nach Assembler

[Stefan (Gast)]

Servus!

Folgende Funktion is beim WinAVR als Inline Assembler dabei.

Da ich ein Ende der Funkbrücke von Benedikt K. mit Assembler 
programmieren möchte, muss ich auch die CRC vom WinAVR für Assembler 
umschreiben.
Sie schaut so aus:

static __inline__ uint16_t _crc_ccitt_update (uint16_t __crc, uint8_t __data)
{
    uint16_t __ret;

    __asm__ __volatile__ (
        "eor    %A0,%1"          "\n\t"

        "mov    __tmp_reg__,%A0" "\n\t"
        "swap   %A0"             "\n\t"
        "andi   %A0,0xf0"        "\n\t"
        "eor    %A0,__tmp_reg__" "\n\t"

        "mov    __tmp_reg__,%B0" "\n\t"

        "mov    %B0,%A0"         "\n\t"

        "swap   %A0"             "\n\t"
        "andi   %A0,0x0f"        "\n\t"
        "eor    __tmp_reg__,%A0" "\n\t"

        "lsr    %A0"             "\n\t"
        "eor    %B0,%A0"         "\n\t"

        "eor    %A0,%B0"         "\n\t"
        "lsl    %A0"             "\n\t"
        "lsl    %A0"             "\n\t"
        "lsl    %A0"             "\n\t"
        "eor    %A0,__tmp_reg__"

        : "=d" (__ret)
        : "r" (__data), "0" (__crc)
        : "r0"
    );
    return __ret;
}

Ich hab sie jetzt so umgeschrieben:

.def wl = r0
.def crc0 = r16
.def crc1 = r17


 eor  crc0, XL
 mov  wl, crc0
 swap  crc0
 andi  crc0, 0xF0
 eor  crc0, wl
 mov  wl, crc1
 mov  crc1, crc0
 swap  crc0
 andi  crc0, 0x0F
 eor  wl, crc0
 lsr  crc0
 eor  crc1, crc0
 eor  crc0, crc1
 lsl  crc0
 lsl  crc0
 lsl  crc0
 eor  crc0, wl

Dass das _tmp_reg_ gleich r0 is und worin die Parameter stehn is mir 
schon klar, doch wo steht der Rückgabewert __ret dann drinnen? In 
crc1:crc0?

MfG

Stefan

[Stefan (Gast)]

Ja, hat sich erledigt. Es ist so, dass das Ergebnis in crc1:crc0 
steht...
Die Routine vom ELM-Chan unten, die ich zuerst verwendete liefert ein 
andres Ergebnis und braucht mehr Takte, obwohl auch CCITT dabeisteht. 
Vielleicht hab ich sie auch nur falsch angewendet, aber es passt jetzt.

;-----------------------------------------------;
; Generate/Check CRC(-CCITT)
;
; Register Variables
;  Call:  crc[1:0]    = CRC working register
;         src         = Source data to be checked
;         lc,tmp[1:0] = <don't care> (high register must be allocated)
;
;  Result:crc[1:0]    = Updated
;         src         = 0
;         lc,tmp[1:0] = broken
;
; Size  = 12 words
; Clock = 66..74 cycles (+ret)
; Stack = 0 byte
;
; To generate a CRC:
; 1. Clear CRC working register.
; 2. Process all data bytes in the block.
; 3. Process two bytes of zero.
; 4. The CRC will be found in the working register.
; 5. Append crc1 and crc0 to the block data.
;
; To check block:
; 1. Clear CRC working register.
; 2. Process all data bytes in the block and following CRCs.
; 3. The block is correct if the working register is zero.


crc:
  ldi  tmp1,0b00010000  ;CRC-CCITT (2^16+2^12+2^5+2^0)
  ldi  tmp0,0b00100001  ;/
  ldi  lc,8    ; Loop count = 8
  lsl  src    ;--- bit processing loop
  rol  crc0    ;Shift-in a bit into working reg.
  rol  crc1    ;/
  brcc  PC+3    ;If pushed out a bit "1", divide it.
  eor  crc1,tmp1  ;
  eor  crc0,tmp0  ;/
  dec  lc    ;Repeat until end of loop
  brne  PC-7    ;/
  ret

Ok, sie braucht dafür weniger FLASH

Gibt es da einen Unterschied zwischen den beiden, oder sonstige Vor- und 
Nachteile?

MfG

Stefan