Schnellste Software-SPI Implementierung auf AVR

[Tim . (cpldcpu)]

Hier mal ein Puzzle für die AVR-Assembler-Hacker: Wie viele Taktzyklen 
benötigt man pro Bit für eine Software-SPI Implementierung als Master?

Randbedingungen:
-Es werden nur Daten gesendet. Dazu sind zwei Leitungen notwendig: SCK 
und MOSI.
-Beide Leitungen befinden sich auf dem gleichen Port und können demnach 
mit einem Befehl geschrieben werden.
-Die Daten werden auf der steigenden Flanke von SCK gesampled. Demnach 
können Daten auf der fallenden Flanke geändert werden.
-SCK muss nicht symmetrisch sein.

Ich komme auf ein Minimum von 5 Taktzyklen:

   OUT PORT, Rx
   SBRC Ry,bit
   OUT PORT, Ry
   SBI PORT, clkbit

[Detlef K. (adenin)]

Wann Du das mal für 8 Bit schreiben würdest, dann können wir 
AVR-Assembler-Hacker mehr dazu sagen. :)

[Ralph (Gast)]

Wenn du schnell haben willst nimm die HW SPI, alles andere ist Murks.

[Tim . (cpldcpu)]

Hier als Ausgangsbasis meine aktuelle C-Implementierung. Mit dieser 
kommt man auf fck/10. (1.6 MHz SCK bei 16Mhz Taktfrequenz.

inline void spiwrite(uint8_t c) {
  uint8_t i;
  uint8_t mask1=SPIPORT & ~( (1<<SCK) | (1<<MOSI) );
  uint8_t mask2=mask1 | (1<<MOSI);
  
  /* Assumed state before call: SCK- Low, MOSI- High */  
  for (i=0; i<8 ;i++)
  {
    if (!(c&0x80)) SPIPORT = mask1;  // set data low
    
    SPIPORT |=  (1<< SCK); // SCK hi , data sampled here
    SPIPORT = mask2;       // SCK low, MOSI hi
    c<<=1;            
  }
  /* State after call: SCK Low, MOSI high */
}

Dies ist das Ergebnis mit AVRGCC und -O1:

inline void spiwrite(uint8_t c) {
  uint8_t i;
  uint8_t mask1=SPIPORT & ~( (1<<SCK) | (1<<MOSI) );
 31a:  35 b1         in  r19, 0x05  ; 5
 31c:  37 7d         andi  r19, 0xD7  ; 215
  uint8_t mask2=mask1 | (1<<MOSI);
 31e:  23 2f         mov  r18, r19
 320:  28 60         ori  r18, 0x08  ; 8
 322:  98 e0         ldi  r25, 0x08  ; 8
  
  /* Assumed state before call: SCK- Low, MOSI- High */
  
  for (i=0; i<8 ;i++)
  {
    if (!(c&0x80)) SPIPORT = mask1;  // set data low
 324:  88 23         and  r24, r24
 326:  0c f0         brlt  .+2        ; 0x32a <writecommand+0x12>
 328:  35 b9         out  0x05, r19  ; 5
    
    SPIPORT |=  (1<< SCK); // SCK hi , data sampled here
 32a:  2d 9a         sbi  0x05, 5  ; 5
    SPIPORT = mask2;       // SCK low, MOSI hi
 32c:  25 b9         out  0x05, r18  ; 5
    c<<=1;            
 32e:  88 0f         add  r24, r24
 330:  91 50         subi  r25, 0x01  ; 1
  uint8_t mask1=SPIPORT & ~( (1<<SCK) | (1<<MOSI) );
  uint8_t mask2=mask1 | (1<<MOSI);
  
  /* Assumed state before call: SCK- Low, MOSI- High */
  
  for (i=0; i<8 ;i++)
 332:  c1 f7         brne  .-16       ; 0x324 <writecommand+0xc>
/* SPI general support functions */

void writecommand(uint8_t c) {
  RSPORT &= ~(1 << RS);
  spiwrite(c);
}
 334:  08 95         ret

[Tim . (cpldcpu)]

Wie man sieht, hat der Compiler schon einige ziemlich clevere 
Optimierungen eingebaut. Auf den ersten Blick kann man mit Assembler nur 
einen Taktzyklus herausoptimieren, mit Änderung der Funktion 2.

Die aktuelle C-Version ist schon schneller als der übliche verbreitete 
Code:

  // Fast SPI bitbang swiped from LPD8806 library
    for(uint8_t bit = 0x80; bit; bit >>= 1) {
      if(c & bit) *dataport |=  datapinmask;
      else        *dataport &= ~datapinmask;
      *clkport |=  clkpinmask;
      *clkport &= ~clkpinmask;
    }

[Tim . (cpldcpu)]

Nach loop-unrolling, und einigen Assembleroptimierungen komme ich auf 5 
Taktzyklen pro Bit, also fck/5. Geht es noch schneller?

inline void spiwrite(uint8_t c) {
  uint8_t i;
  uint8_t mask1=SPIPORT & ~( (1<<SCK) | (1<<MOSI) );
  uint8_t mask2=mask1 | (1<<MOSI);
  
  // Assumed state before call: SCK- Low, MOSI- High
  
    asm volatile(
    
    "    sbrs  %0,7  \n\t"    // 1 bit7
    "    out    %1,%2  \n\t"    // 2
    "    sbi    %1,%4  \n\t"    // 4
    "    out    %1,%3  \n\t"    // 5
    
    "    sbrs  %0,6  \n\t"    // bit6
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    "    sbrs  %0,5  \n\t"    // bit5
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    "    sbrs  %0,4  \n\t"    // bit4
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    "    sbrs  %0,3  \n\t"    // bit3
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    "    sbrs  %0,2  \n\t"    // bit2
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    "    sbrs  %0,1  \n\t"    // bit1
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    "    sbrs  %0,0  \n\t"    // bit0
    "    out    %1,%2  \n\t"
    "    sbi    %1,%4  \n\t"
    "    out    %1,%3  \n\t"
    :  
    :  "r" (c), "I" (_SFR_IO_ADDR(SPIPORT)), "r" (mask1), "r" (mask2), "I" (SCK)
    );

  // State after call: SCK Low, MOSI high
}

[Martin S. (msperl)]

Theoretisch (nicht getestet) sollte ein MASTER-SPI-TX wie folgt auch in 
4 Zyklen gehen:

;; DATAR   ... Register mit den zu transferierenden Daten
;; PORTX   ... Das PORT Register für den Transfer
;; PINX    ... Das PIN  Register für den Transfer
;; OUTR    ... Register mit  dem "Standard" Wert für PORTX
;; PINMOSI ... Das bit im PORT/PIN Register für MOSI
;; PINSCK  ... Das bit im PORT/PIN Register für SCK
;; SCKPINR ... Register mit dem PINSCK bit gesetzt (1<<PINSCK)
;; BITNUM  ... das wievielte bit soll verschickt werden?
  bst DATAR  ,BITNUM
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  out PINX   ,SCKPINR

wenn man das bei den weiteren Bits etwas umsortiert, so kann SCK auch 
symmetrisch sein - geht halt nur beim ersten Bit nicht.

Sieht dann halt so aus:

;; DATAR   ... Register mit den zu transferierenden Daten
;; PORTX   ... Das PORT Register für den Transfer
;; PINX    ... Das PIN  Register für den Transfer
;; OUTR    ... Register mit  dem "Standard" Wert für PORTX
;; PINMOSI ... Das bit im PORT/PIN Register für MOSI
;; PINSCK  ... Das bit im PORT/PIN Register für SCK
;; SCKPINR ... Register mit dem PINSCK bit gesetzt (1<<PINSCK)
  bst DATAR  ,7
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,6
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,5
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,4
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,3
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,2
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,1
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR
  bst DATAR  ,0
  out PINX   ,SCKPINR
  bld OUTR   ,PINMOSI
  out PORTX  ,OUTR

SPI-MASTER-RX ist auch nicht viel aufwändiger:

;; DATAR   ... Register mit den empfangenen Daten
;; PORTX   ... Das PORT Register für den Transfer
;; PINX    ... Das PIN  Register für den Transfer
;; OUTR    ... Register mit  dem "Standard" Wert für PORTX
;; PINSCK  ... Das bit im PORT/PIN Register für SCK
;; SCKPINR ... Register mit dem PINSCK bit gesetzt (1<<PINSCK)
;; PINMISO ... Das bit im PORT/PIN Register für MISO
;; BITNUM  ... das wievielte bit soll verschickt werden?
  out PORTX ,OUTR
  in  TMP   ,PINX
  bst TMP   ,PINMISO
  out PINX  ,SCKPINR
  bld DATAR ,BITNUM

und ist mit 5 Zyklen fast symmetrisch - fuer volle SCK-Symmetrie ein NOP 
am Schluss anhaengen.

und zuletzt beides zusammengesetzt SPI-MASTER-TX/RX in 7 Zyklen:

;; DATAR   ... Register mit den zu transferierenden und empfangenden Daten
;; OUTR    ... Register mit  dem "Standard" Wert für PORTX
;; PORTX   ... Das PORT Register für den Transfer
;; PINX    ... Das PIN  Register für den Transfer
;; PINMOSI ... Das bit im PORT/PIN Register für MOSI
;; PINSCK  ... Das bit im PORT/PIN Register für SCK
;; SCKPINR ... Register mit dem PINSCK bit gesetzt (1<<PINSCK)
;; PINMISO ... Das bit im PORT/PIN Register für MISO
;; BITNUM  ... das wievielte bit soll verschickt werden?
  bst DATAR ,BITNUM
  bld OUTR  ,PINMOSI
  out PORTX ,OUTR
  in  TMP   ,PINX
  bst TMP   ,PINMISO
  bld DATAR ,BITNUM
  out PINXX ,SCKPINR

und ist mit 7 Zyklen fast symmetrisch - fuer volle SCK-Symmetrie wieder 
ein NOP am Schluss anhaengen.

Martin

P.s: Eines der Male wo das T-Flag wirklich nuetzlich ist...

P.p.s: ich bin nicht sicher, aber vielleicht liesse sich im TX/RX Fall 
bei geschickten HW-Randbedingungen (z.b. "pin-wahl" MISO/MOSI auf 
PORT0/7) auch die BST/BLD bloecke durch LSR/LSL und ROL/ROR ersetzen und 
so eine Zyklus sparen.

Dürfte aber erfordern dass die PORT Werte der "restlichen" Pins egal 
sind und sich ändern dürfen - sprich:
Alle anderen Pins sind auf INPUT mit externem Pullup - damit spielt 
interner Pullup Wechsel keine Rolle.
Allerdings ist der Fall TX+RX gleichzeitig doch eher selten, sodass ich 
mir das Austuefteln diese Variante spare...

[Tim . (cpldcpu)]

Hallo Martin,

Super Trick! Das T-Flag existierte bei mir gedanklich gar nicht, so 
wenig Nutzen hatte es bisher. Für diese Anwendung lässt es sich aber 
ideal einsetzen.

Die Einsparung des zusätzlichen Taktzyklus kommt daher, dass Du die 
Toggle-Funktion nutzt, statt SCK mit SBI zu setzen. Den gleichen Trick 
könnte man auch mit der Bit-Afrage mit SBRS kombinieren, um auf 4 
Taktzyklen pro Bit zu kommen. Allerdings ist die Variante mit dem T-Flag 
wegen des symmetrischen Clocksignals natürlich eleganter.

Noch einen Taktzyklus einzusparen stelle ich mir schwierig vor. Selbst 
mit den Shift-Befehlen muss man irgendwie gleichzeitig das Clock-Signal 
setzten.

[MCUA (Gast)]

>Wie man sieht, hat der Compiler schon einige ziemlich clevere ...

Was er nicht eingebaut hat,
mit ein bisschen zus. Logic (mit Enab- u AVR-Clk -Anschluss) kann man 
den SCLK autom schalten.
Dann kann man mit

BST Ra,b1
BLD Rb,b2
OUT Px,Rb

jedes einzelne Bit in 3 Takten rausschicken.

[Tim . (cpldcpu)]

MCUA schrieb:
> Was er nicht eingebaut hat,
> mit ein bisschen zus. Logic (mit Enab- u AVR-Clk -Anschluss) kann man
> den SCLK autom schalten.

Naja, aber die Idee war doch eine reine Softwareimplementierung :)

Ich nutze den Code übrigens für Echtzeitdebugging, indem ich über zwei 
unbenutzte Pins Debugginginformationen ausgebe und mit einem LA 
analysiere. Das ist z.B. für V-USB Projekte auf dem AVR sehr nützlich.

[Markus W. (Firma: guloshop.de) (m-w)]

MCUA schrieb:
> mit ein bisschen zus. Logic (mit Enab- u AVR-Clk -Anschluss) kann man
> den SCLK autom schalten.

Meintest du damit das Schalten eines Timer-Ausgangs (z.B. OC0A), der 
dann als CLK verwendet wird? Könnte auch gehen.