SCALETTA LEZIONE SERT E9 -- 29 novembre 2012

*** Stampa di numeri in decimale

1 Per scrivere un numero in decimale l'algoritmo e' piu' complesso:
     Si divide ripetutamente per 10, prendendo nota dei resti, fino a quando
     il divisore non diventa zero
     Si stampano i resti in ordine LIFO, dall'ultimo al primo
  1.1 Scrivere la funzione putu() per stampare un unsigned long in decimale
      1.1.1 Prima versione con modulo e divisione intera
            +----------------------------------------------------------+
            |void putu(unsigned long v)                                |
            |{                                                         |
            |    char buf[11]; /* log10(2^32-1)=9.63 (+1 for '\0') */  |
            |    int i, r;                                             |
            |    if (v < 10UL) {                                       |
            |        putc(v + '0');                                    |
            |        return;                                           |
            |    }                                                     |
            |    i = 10;                                               |
            |    buf[i] = '\0';                                        |
            |    while (v != 0) {                                      |
            |        r = v % 10;                                       |
            |        v = v / 10;                                       |
            |        buf[--i] = (char)('0'+r);                         |
            |    }                                                     |
            |    puts(buf+i);                                          |
            |}                                                         |
            +----------------------------------------------------------+
      1.1.2 Provare a compilare: non funziona!
              uart1.o: In function `putu':
              uart1.c:(.text+0x120): undefined reference to `__aeabi_uidiv'
              uart1.c:(.text+0x130): undefined reference to `__aeabi_uidivmod'
            Il processore non ha istruzioni per divisione e modulo, il compilatore
            le sostituisce con invocazioni di funzioni, ma il linker non le trova
      1.1.3 Ottimizzare il codice per eseguire solo la divisione, non il modulo:
            +-------------------------------+
            |[...]                          |
            |while (v != 0) {               |
            |    unsigned long w = v / 10;  |
            |    r = v - w * 10;            |
            |    v = w;                     |
            |    buf[--i] = (char)('0'+r);  |
            |}                              |
            +-------------------------------+
      1.1.4 Provare a compilare:
              uart1.o: In function `putu':
              uart1.c:(.text+0x124): undefined reference to `__aeabi_uidiv'
  1.3 Aggiungere al Makefile il supporto per l'emulatore software
  1.4 Aggiungere extern per putu() in comm.h:   extern void putu(unsigned long);
  1.5 Provare la funzione putu() stampando in main() il valore 0xbadc0de

2 Stampare valori decimali con segno
  2.1 Scrivere la funzione putd() per stampare valori in decimale con segno
      +--------------------+
      |void putd(long v)   |
      |{                   |
      |    if (v < 0) {    |
      |        putc('-');  |
      |        v = -v;     |
      |    }               |
      |    putu(v);        |
      |}                   |
      +--------------------+
  2.2 Aggiungere extern per putd() in comm.h:    extern void putd(long);
  2.3 Provare la funzione putd() stampando in main() il valore -195936478

*** Stampa di numeri in virgola mobile

3 Stampare valori in virgola mobile
  3.1 Scrivere la funzione putf() per stampare valori in virgola mobile (double)
      +-------------------------------+
      |void putf(double v, int prec)  |
      |{                              |
      |    int i;                     |
      |                               |
      |    if (v < 0.0) {             |
      |        putc('-');             |
      |        v = -v;                |
      |    }                          |
      |    putu(v);                   |
      |    putc('.');                 |
      |    for (i=0; i<prec; ++i) {   |
      |        v = v - ((int) v);     |
      |        v = v * 10;            |
      |        putc('0'+(int)v);      |
      |    }                          |
      |}                              |
      +-------------------------------+
  3.2 Aggiungere extern per putf() in comm.h:   extern void putf(double, int);
  3.3 Provare putf() stampando in main() il valore di pigreco con cinque decimali  

*** Debug timer

4 Aggiungere supporto per il debug timer
  4.1 Il Timer 4 del chip EP9302 e' un contatore a 40 bit aggiornato alla frequenza di
      983040 Hz (vedere EP9302, pag. 18-2)
  4.2 Aggiungere nel file ts7250.h le definizioni per l'accesso al Timer 4
      +-------------------------------------------------------------------------------+
      |/*** Timer 4 (40-bit free running debug timer) ***/                            |
      |static const unsigned int Timer4ValueLow        = 0x80810060 / 4;              |
      |static const unsigned int Timer4ValueHigh       = 0x80810064 / 4;              |
      |#define Timer4Enable (1UL<<8)                                                  |
      |#define _timer4_low()   (iomem[Timer4ValueLow])                                |
      |#define _timer4_high()   (iomem[Timer4ValueHigh] & 0xff)                       |
      |#define timer4_start() _iomem_high(Timer4ValueHigh, Timer4Enable)              |
      |#define timer4_stop()  _iomem_low(Timer4ValueHigh, Timer4Enable)               |
      |#define Timer4Freq 983040 /* Hz */                                             |
      |static inline double timer4_getus(void)                                        |
      |{                                                                              |
      |    u32 low, high;                                                             |
      |    double us;                                                                 |
      |    low = _timer4_low();   /* low counter must be read before the high one */  |
      |    high = _timer4_high();                                                     |
      |    us = (low*1000000.0) / Timer4Freq;                                         |
      |    us += high * (4369066666.67); /* 2^32*1,000,000 / Timer4Freq */            |
      |    return us;                                                                 |
      |}                                                                              |
      +-------------------------------------------------------------------------------+
  4.3 Aggiungere inizializzazione del Timer 4 in init.c
      +------------------------------------------+
      |void _init(void)                          |
      |{                                         |
      |    volatile u32 * vector = (u32 *) 0;    |
      |    timer4_stop();                        |
      |    timer4_start();                       |
      |[...]                                     |
      +------------------------------------------+
  4.4 Aggiungere stampe del valore del Timer 4 in main() e endless_led_blinking()

*** Gestione delle interruzioni hardware

5 Ricerca nella documentazione
  5.1 Nel manuale della scheda TS-7250 (pag. 15) si legge che
      il chip EP9302 consente di avere fino a 54 (64 teorici, 10 riservati) 
      interruzioni IRQ o FIQ. Gli IRQ possono essere associati a 32 livelli
      di priorita', e i FIQ a due livelli. Si legge anche che le 19 linee di
      ingresso-uscita digitali possono funzionare come linee di interruzione.
      Per ulteriori informazioni si rimanda al manuale d'uso del chip EP9301.
  5.2 Il manuale del chip EP93xx dedica il capitolo 6 alla gestione
      delle interruzioni (20 pagine). Vengono riassunte qui solo le
      informazioni piu' importanti

6 Descrizione del funzionamento dell'hardware
  6.1 Il chip EP93xx include due VIC (Vectored Interrupt Controller)
      collegati in daisy-chain
  6.2 Ciascun VIC riceve in ingresso 32 linee di interruzione
      6.2.1 In totale il chip EP93xx puo' gestire fino a 64 linee di 
            interruzione (da 64 dispositivi hardware differenti)
  6.3 E' possibile programmare ciascun VIC in modo che fino a 16
      delle linee di interruzione siano gestite in modalita' 
      "vectored"
      6.3.1 Una linea "vectored" puo' solo essere associata ad un
            IRQ (interruzione del processore "normale")  
      6.3.2 L'indirizzo della procedura che dovra' gestire l'interruzione
            "vectored" (ISR, Interrupt Service Routine) e' contenuto in un
            registro del VIC e reso disponibile alla CPU all'occorrenza
            dell'interruzione
      6.3.3 Invece ciascuna linea "non-vectored" puo' essere associata ad un
            IRQ (interruzione del processore "normale") oppure ad un
            FIQ (interruzione del processore "veloce")
      6.3.4 L'indirizzo della procedura che dovra' gestire l'interruzione
            "non-vectored" (ISR) e' determinato dalla CPU via software, a
            partire dal numero associato alla linea di interruzione
  6.4 Priorita' delle interruzioni, dalla massima alla minima:
        - FIQ (interruzioni veloci)
        - Vectored IRQ 0
        - Vectored IRQ 1
        - ...
        - Vectored IRQ 15
        - Non-vectored IRQ
      6.4.1 Finche' e' attiva una interruzione, la CPU non riceve interruzioni
            di priorita' inferiore
      6.4.2 Il meccanismo di priorita' per le interruzioni "vectored" e' 
            legato all'accesso del registro che contiene l'indirizzo della
            ISR
             - la lettura disabilita le interruzioni di priorita' inferiore
             - la scrittura riabilita le interruzioni di priorita' inferiore
  6.5 Vari dispositivi associati alle 64 linee di interruzione
      6.5.1 Si veda tabella 6-1 del manuale del chip EP93xx
  6.6 Le interfacce dei due VIC del chip EP93xx sono identiche; i registri
      si trovano in posizioni analoghe a partire da differenti indirizzi di
      base:
      6.6.1 Indirizzo di base del VIC1: 0x800B0000
      6.6.2 Indirizzo di base del VIC2: 0x800C0000
  6.7 I registri di un VIC sono i seguenti:
      (Base+0000)     R   Stato IRQ
      (Base+0004)     R   Stato FIQ
      (Base+0008)     R   Stato delle linee di interruzione
      (Base+000C)     RW  Selezione delle interruzioni IRQ o FIQ
      (Base+0010)     RW  Abilitazione delle interruzioni
      (Base+0014)      W  Disabilitazione delle interruzioni
      (Base+0018)     RW  Generazione interruzione da software
      (Base+001C)     RW  Cancellazione interruzione da software
      (Base+0020)     RW  Abilitazione programmazione da modo User
      (Base+0030)     RW  Indirizzo ISR attiva, controllo meccanismo priorita'
      (Base+0034)     RW  Indirizzo ISR di default (non-vectored)
      (Base+0100+4*n) RW  Indirizzo ISR interruzione vettorizzata n=0,...,15
      (Base+0200+4*n) RW  Linea della interruzione vettorizzata n=0,...,15

======