Il Microprocessore LEON
1.1 Il Microprocessore LEON
L’architettura del processore LEON si basa sullo standard SPARC a 32 bit (versione 8), il cui set di istruzioni è conforme allo standard IEEE-754. Il codice che descrive il LEON è stato scritto sotto forma di file VHDL (Very high speed circuits Hardware Description Language) da Jiri Gaisler [1.1],
ed è distribuito ed utilizzabile entro i limiti di due licenze:
• La GNU Public Licence (GPL)
• La Lesser GNU Public Licence (LGPL)
I termini di queste licenze consentono di utilizzare il codice VHDL del processore per realizzare un core all’interno di un sistema contenente altri dispositivi integrati (System on Chip, SoC), con il vincolo di rendere disponibili tutte le modifiche apportate al codice stesso, senza dover fare nessun cenno agli altri elementi aggiuntivi del progetto.
1.2 Architettura SPARC
Poiché il processore LEON viene implementato secondo la versione 8 dello SPARC (Scalable Processor ARChitecture), di esso ne verrà dato un breve cenno. Lo SPARC [1.2] è un’architettura di istruzioni RISC, con dati interi su 32 bit e floating-point su 32, 64 e 128 bit secondo lo standard IEEE 754. Si tratta di un’architettura load/store nella quale, per la manipolazione dei dati, possono essere utilizzati solo i registri e non locazioni di memoria. Le
istruzioni di load/store in memoria indirizzano uno spazio lineare di 232
byte, consentendo l’indirizzamento di byte singoli nella modalità big endian (la MSB viene caricata per prima). Come tutte le architetture RISC, SPARC sfrutta la tecnica della pipeline e per ottimizzarla usa un branch delay slot, ciò significa che l’istruzione che segue un branching è sempre eseguita.
Sono disponibili da 2 a 32 set di 24 registri generali che si dividono in local %l[0-7], in %i[0-7] e out %o[0-7] e che sono utilizzati mediante un sistema di finestre sovrapposte. L’architettura SPARC fornisce anche 8 registri global %g[0-7], 32 registri floating-point %f[0-31] ed alcuni registri di controllo/stato (%pc, %sp, %psr ecc.). Il set di istruzioni, tutte codificate su 32 bit, è molto semplice ed è formato da 72 istruzioni di base che per la maggior parte utilizzano 3 registri (origine 1, origine 2 e destinazione). Tutte le procedure condividono i registri globali mentre i registi %l[0-7], %i[0-7] e %o[0-7] costituiscono la register window dove i registri di output sono sovrapposti con quelli di input della subroutine da essa chiamata. Se ad esempio un procedura A chiama una procedura B che a sua volta invoca una procedura C si avrà la situazione illustrata nella figura 1.2. Le finestre hanno un andamento circolare e l’attuale register window è indirizzata da CWP (current window pointer) contenuto nei 5 bit meno significativi di %psr e modificabile mediante save e restore.
Figura 1.2 - Register window
Strutturalmente il processore è costituito da 3 unità fondamentali (figura 1.1) :
1. unità intera (Integer Unit, IU ): contiene registri di uso generale (general pourpose) e controlla le operazioni del processore
2. unità floating-point (Floating Point Unit, FPU)
3. coprocessore (Coprocessor, CP): opzionale e dipendente dall’implementazione.
Ognuna di queste unità utilizza i propri registri, tutti a 32 bit. FPU e CP sono connessi alla IU e ricevono da quest’ultima i segnali di controllo per il loro funzionamento. Il processore può essere in due modalità: utente (user mode) o supervisore (supervisor mode). In modalità supervisore può eseguire ogni istruzione, incluse quelle privilegiate mentre in modalità utente ogni tentativo di eseguire un’istruzione privilegiata causerà un’eccezione di tipo trap: l’istruzione non viene eseguita e si passa a quella immediatamente successiva.
1.3 Amba BUS
Le varie unità funzionali che costituiscono il processore LEON sono interconnesse attraverso l’utilizzo di 2 bus: AMBA AHB (Advanced High performance Bus) e AMBA APB (Advanced Peripheral Bus). I 2 bus svolgono le seguenti funzioni:
AMBA AHB: interconette il processor core (integer unit e i controllori della cache) al controllore della memoria, all’APB bridge e ad eventuali altre unità a cui sono richieste alte prestazioni. Il processore è l’unico master sul bus mentre ci sono due slave: il controllore della memoria e l’APB bridge. L’AMBA AHB è in grado di connettere fino a 16 unità master e un numero elevato di unità slave.
AMBA APB: interconette l’AMBA AHB con le unità periferiche attraverso l’APB bridge. Le unità periferiche connesse all’APB sono: il controllore delle interruzioni, il timer, 2 unità uart e la I/O port. L’APB bridge è connesso all’AHB come unità slave, mentre è l’unica unità master per l’AMBA APB bus.
1.3.a Bus AHB
Permette di realizzare trasferimenti dati ad alta velocità e consente: • trasferimenti burst;
• transizioni split;
• handover tra i master presenti sul bus in un unico ciclo; • operazioni su un unico fronte di clock;
• implementazione non tristate; • trasferimenti dati fino a 128 bit.
Tipicamente il sistema AMBA AHB è costituito da:
• AHB master: il master è capace di iniziare un’operazione di lettura o scrittura fornendo un indirizzo e informazioni di controllo. Ad ogni istante un solo master è abilitato ad utilizzare il bus. (figura 1.3) • AHB slave: lo slave risponde ad un’operazione di lettura o scrittura
effettuata in un dato range nello spazio di indirizzamento. Segnala al master attivo il successo, il fallimento o un’operazione di attesa (waiting) del trasferimento dati richiesto.(figura 1.4).
Figura 1.3 - AHB master Figura 1.4 - AHB slave
• AHB arbiter : l’arbitro assicura che ad ogni istante un solo master sia autorizzato ad iniziare il trasferimento dati. Ciascun master ha una interfaccia di tipo request /grant con l’arbitro e può richiedere un accesso esclusivo al bus con il segnale HLOCK. Il protocollo di arbitraggio non è specificato nello standard e viene definito internamente all’applicazione. (figura 1.5)
• AHB decoder: il decoder è utilizzato per decodificare gli indirizzi dei trasferimenti e fornisce un segnale di selezione allo slave coinvolto nel trasferimento. (figura 1.6)
Il protocollo dell’AMBA AHB bus è progettato per essere usato con uno schema di interconnessione centrale multiplexato.
Tutti i master inviano l’indirizzo e i segnali di controllo indicanti il trasferimento che vorrebbero effettuare e l’arbitro decide quale master può inviare questi segnali a tutti gli slave. È necessario anche un decoder centralizzato, per controllare i dati letti e i segnali di risposta multiplexati e selezionare il segnale appropriato proveniente dallo slave coinvolto nel trasferimento.
Figura 1.5 - Arbitro AHB Figura 1.6 - AHB decoder
1.3.b Bus APB
Il bus APB è stato progettato per avere bassi consumi di potenza e interfacce semplificate sulle periferiche. Per questo motivo si adatta particolarmente a periferiche con banda stretta che non richiedono le alte performance di un bus in pipeline. Anche la temporizzazione è molto semplice in quanto è presente un solo master (l’APB bridge), la
selezione degli slave avviene attraverso i segnali dedicati PSELx (uno per ogni slave) e l’esecuzione del comando (lettura o scrittura) attraverso il segnale PENABLE. Per rappresentare l’attività dell’APB si usa il diagramma di stato di figura 1.7.
• IDLE: stato di default per il bus APB;
• SETUP: quando è richiesto un trasferimento il bus si sposta in questo stato e viene asserito l’opportuno segnale di selezione PSELx. Il bus rimane in questo stato per un solo ciclo e al clock successivo si sposta nello stato enable,
• ENABLE: in questo stato viene asserito il segnale PENABLE. I segnali di indirizzo, scrittura e selezione devono rimanere stabili durante il passaggio tra i due stati. Anche questo stato dura un solo ciclo e dopo, se non sono richiesti altri trasferimenti, torna nello stato idle, se invece ci sono altri trasferimenti riguardanti la stessa periferica va nello stato setup.
L’operazione di scrittura ( figura 1.8) ha inizio con il cambiamento, dopo il fronte di clock, dell’indirizzo (PADDR), del dato da scrivere (PWDATA), del segnale di scrittura (PWRITE) e del segnale di selezione della periferica (PSELx).
Il primo ciclo di clock è il ciclo di SETUP mentre al successivo fronte di clock, con l’asserimento del segnale di abilitazione (PENABLE), entriamo nel ciclo di ENABLE alla fine del quale il trasferimento è completato. In questo ciclo l’indirizzo, il dato e i segnali di controllo rimangono validi. Alla fine del trasferimento il segnale PENABLE deve essere rimosso ed anche il segnale di selezione deve tornare basso, a meno che il trasferimento non sia immediatamente seguito da un altro per la stessa periferica. Per ridurre i consumi di potenza l’indirizzo e il segnale di scrittura non cambiano finché non comincia un altro trasferimento.
Nell’operazione di lettura (figura 1.9) la temporizzazione dei segnali di indirizzo, scrittura, selezione e abilitazione è la stessa del trasferimento di scrittura mentre il dato deve essere fornito dallo slave durante il ciclo
ENABLE e viene campionato sul fronte in salita del clock alla fine del ciclo.
Figura 1.8 - Trasferimento in scrittura. Figura 1.9 - Trasferimento in lettura.
1.4 APB bridge
L’ APB bridge è l’unico master presente sul bus APB ed è anche uno slave sul bus AHB. La sua funzione è quella di memorizzare i trasferimenti effettuati sul bus AHB (diretti a una periferica APB) e in seguito pilotare opportunamente il bus APB in modo da rendere effettivi tali trasferimenti.
Il bridge esegue le seguenti operazioni:
• campiona gli indirizzi e li mantiene validi per tutto il trasferimento. • decodifica gli indirizzi e genera i corrispondenti segnali di selezione
(PSELx) per ciascuna periferica.
• invia i dati dell’AHB sul bus APB in caso di trasferimento in scrittura.
• manda i dati dell’APB sul bus AHB nei trasferimenti in lettura. • pilota il segnale PENABLE che regola la temporizzazione dell’APB.
1.5 Architettura del microprocessore LEON
Il modello del LEON [1] implementato è composto dalle seguenti unità: • Integre Unit con 32 register
window
• 2 cache separate per istruzioni e dati
• una RAM AHB da 32 Kbyte • un APB bridge
• un controllore delle interruzioni
• 2 contatori a 24 bit • un watchdog
• 2 porte seriali (UARTs) • una porta di I/O
• un controllore AHB
• un controllore di memoria • un blocco di protezione
scrittura
• Interfaccia generica per FPU e coprocessore
Di questi blocchi verrà fatta una breve descrizione senza entrare nei dettagli della loro realizzazione, per ulteriori approfondimenti si rimanda a [1].
1.5.a L’Integer Unit
La Integer Unit dell LEON implementa lo standard SPARC V8 incluse le istruzioni di moltiplicazione e divisione. La configurazione scelta è caratterizzata da :
• 5 stadi di pipeline per le istruzioni.
• Interfacce separate per data cache e instruction cache. • 32 register windows (NWINDOWS).
• Moltiplicatore 16x16.
• MAC (moltiplicatore con accumulatore) 16x16 bit con accumulatore a 40 bit.
I 5 stadi della pipeline sono :
1. FE (instruction fetch) : se l’instruction cache è abilitata viene prelevata l’istruzione dalla cache, altrimenti la fase di fetch è rimandata al controllore di memoria. L’istruzione è valida alla fine di questa fase e viene registrata all’interno della IU.
2. DE (instruction decode) : viene decodificata l’istruzione e vengono letti gli operandi. L’indirizzo del target per le istruzioni CALL e Branch viene calcolato in questa fase.
3. EX (execute) : sono eseguite operazioni aritmetiche, logiche e di shift. Viene generato l’indirizzo per le operazioni di memoria (load e store) e per le istruzioni JMPL e RETT.
4. ME (memory) : viene effettuato l’accesso alla data cache. Per le letture nella cache il dato deve essere valido alla fine di questo stadio e per le scritture in memoria il dato è scritto nella data cache in questo stadio.
5. WR (write) : il risultato delle operazioni aritmetiche, logiche, di shift e i dati letti nella cache vengono scritti nei registri destinatari.
1.5.b Reset del processore
Il processore viene resettato asserendo l’ingresso RESET almeno per un ciclo di clock. L’esecuzione ha inizio dall’indirizzo 0. La tabella 1.1 indica i valori dei registri del processore sensibili all’operazione di reset, gli altri mantengono invariato il loro valore.
Registro PC program counter nPC next PC PSR processor status reg CCR cache control reg. Valore reset 0x0 0x4 ET=0, S=1 0x0
Tabella 1.1 – Registri sensibili al reset del processore LEON
1.5.c Eccezioni
Il processore LEON aderisce al modello generale di trap dello Sparc. Nella tabella 1.2 sono mostrate le trap implementate, il tipo e la priorità.
Trap TT Priorità Descrizione
Reset 0x00 1 Reset
write error 0x2b 2 Errore nel write buffer
instruction_access_error 0x01 3 Errore durante la fase di fetch illegal_instruction 0x02 5 Istruzione non implementata
privileged_instruction 0x03 4 Esecuzione di istruzione privilegiata in modalità user
fp_disabled 0x04 6 Istruzione FP con FPU disabilitata
cp_disabled 0x24 6 Istruzione CP con coprocessore
disabilitato
watchpoint_detect 0x0b 7 Watchpoint
window_overflow 0x05 8 Istruzione SAVE in finestra non valida
window_underflow 0x06 8 Istruzione RESTORE in finestra non valida
register_hardware_error 0x20 9 Errore register file EDAC (solo LEON-FT)
Mem_address_not_aligned 0x07 10 Accesso in memoria ad un indirizzo non allineato
fp_exception 0x08 11 Eccezione FPU
cp_exception 0x28 11 Eccezione del coprocessore
data_access_exception 0x09 13 Errore di accesso durante un’istruzione load o store
tag_verflow 0x0a 14 Overflow nell’operazione aritmetica
con tag
Divide_exception 0x2a 15 Divisione per zero
interrupt_level_1 0x11 31 Interruzione asincrona 1 interrupt_level_2 0x12 30 Interruzione asincrona 2 interrupt_level_3 0x13 29 Interruzione asincrona 3 interrupt_level_4 0x14 28 Interruzione asincrona 4 interrupt_level_5 0x15 27 Interruzione asincrona 5 interrupt_level_6 0x16 26 Interruzione asincrona 6 interrupt_level_7 0x17 25 Interruzione asincrona 7 interrupt_level_8 0x18 24 Interruzione asincrona 8 interrupt_level_9 0x19 24 Interruzione asincrona 9 interrupt_level_10 0x1a 22 Interruzione asincrona 10 interrupt_level_11 0x1b 21 Interruzione asincrona 11 interrupt_level_12 0x1c 20 Interruzione asincrona 12 interrupt_level_13 0x1d 19 Interruzione asincrona 13 interrupt_level_14 0x1e 18 Interruzione asincrona 14 interrupt_level_15 0x1f 17 Interruzione asincrona 15
trap_instruction 0x80-0xff 16 Trap software
1.5.d Memoria cache
Il processore LEON implementa una architettura Harvard con bus dati e bus indirizzi separati, connessi a 2 controllori di cache indipendenti . In figura 1.11 sono mostrati il controllore per la cache
delle istruzioni (IC) e quello per la cache dei dati (DC). Questi sono collegati al bus AMBA AHB attraverso un’interfaccia comune (AC). Il processore Sparc oltre all’indirizzo genera anche un identificatore, ASI, che viene utilizzato con le istruzioni LDA e STA per leggere e scrivere negli spazi di indirizzamento alternativi. Per default le aree definite cacheable sono quelle della PROM e della RAM.
Figura 1.11 - Controllori memoriacache
ASI USO
0x0, 0x1, 0x2, 0x3
Cache miss forzata (aggiorna la cache se il dato è già presente, altrimenti fa un rimpiazzo allocando una nuova linea)
0x4, 0x7 Cache miss forzata (aggiorna la cache se il dato è già resente)
0x5 Flush della cache istruzioni
0x6 Flush della cache dati
0x8, 0x9, 0xA, 0xB
Accesso normale alla cache
0xC Tags della cache istruzioni
0xD Dato della cache istruzioni
0xE Tags della cache dati
0xF Dato della cache dati
Tabella 1.3 – Uso degli identificatori ASI
Le cache possono essere configurate con dimensioni che vanno da 1 a 32 kbyte, con linee (blocchi di indirizzi contigui) di 16-32 bytes. Ad ogni linea è associato un tag della cache costituito da un campo tag e da un bit di validità per ogni sottoblocco costituito da 4 byte.
Sono controllate entrambe da un unico registro di controllo (Cache Control Register, CCR) che determina lo stato delle cache (disabilitato, abilitato o congelato) e comanda l’eventuale svuotamento (flush).
1.5.e I-Cache
Ogni volta che si verifica una cache miss (ovvero l’istruzione cercata non è presente nella cache), viene fatto il fetch dell’istruzione dalla memoria e vengono aggiornati la linea dati e il tag corrispondenti.
Se, nel registro di controllo della cache (CCR), è abilitata la fetch di burst di istruzioni, la linea della cache viene riempita dalla memoria principale a partire dall’indirizzo mancante fino alla fine della linea ed allo stesso tempo le istruzioni sono passate alla IU. Se questa non può accettare il flusso di istruzioni, ad esempio a causa di istruzioni che richiedono più di un ciclo di clock, la IU viene arrestata finché la linea non è stata completamente riempita. Se la integer unit esegue un’istruzione con trasferimento di controllo (JMPL/RETT/TRAP/CALL/branch) durante il riempimento della linea quest’ultimo viene terminato quando si verifica la fetch successiva. Se durante il riempimento di una linea con la IU bloccata si verifica un errore di accesso in memoria, il bit di validità corrispondente non viene settato. Se in seguito la IU fa una fetch all’indirizzo che ha generato l’errore, si verifica una miss e viene effettuato un nuovo accesso in memoria a quell’indirizzo e se l’errore persiste viene generata una trap di tipo 0x1 (errore durante la fase di fetch).
1.5.f D-Cache
Quando si verifica una miss in lettura viene copiato dalla memoria principale un dato a 4 byte. La tecnica utilizzata per la scrittura di dati è quella del write-through (in caso di successo il dato viene scritto sia in cache che nella memoria principale) senza allocazione in caso di insuccesso (write miss). La cache dati implementa anche il write buffer (WRB). Questo è costituito da 3 registri a 32 bit ed è usato per mantenere temporaneamente i dati che devono essere scritti in memoria.
1.5.g Il controllore AHB
Il controllore del bus AHB è composto da 2 registri: quando si verifica un errore l’indirizzo dell’accesso viene memorizzato nel registro failing address mentre in un registro di stato (AHB status register) viene memorizzato il numero del master che ha fallito l’accesso, la dimensione del trasferimento fallito e se si trattava di una scrittura o di una lettura. Al verificarsi di un errore viene generata un’interruzione per informare il processore.
1.5.h APB bridge
Come gia’ illustrato il LEON utilizza il bus AMBA AHB per collegare i controllori di cache del processore al controllore di memoria. Il processore è l’unico master presente sul bus mentre ci sono 2 slave : il controllore di memoria e il bridge APB. Le periferiche connesse al bus APB possono comunicare con la IU attraverso il bridge che è l’unico master dell’APB. Queste periferiche sono controllate attraverso registri che sono mappati sul bus in accordo alla tabella 1.4.
INDIRIZZO REGISTRO INDIRIZZO REGISTRO 0x80000000 Configurazione della memoria 0x80000060 Contatore scaler 0x80000004 Configurazione della memoria 0x80000064 Ricarica scaler 0x80000008 Configurazione della memoria 0x80000070 Dato uart1
0x8000000C AHB indirizzo fallito 0x80000074 Stato uart1
0x80000010 Stato AHB 0x80000078 Controllo uart1
0x80000014 Controllo della cache 0x8000007C Scaler uart1
0x80000018 Power-down 0x80000080 Dato uart2
0x8000001C Protezione in scrittura 0x80000084 Stato uart2
0x80000020 Protezione in scrittura 0x80000088 Controllo uart2
0x80000024 Configurazione del
LEON
0x8000008C Scaler uart2
0x80000040 Contatore timer1 0x80000090 Maschera interruzioni
e priorità
0x80000044 Ricarica timer1 0x80000094 Interruzioni pendenti
0x80000048 Controllo timer1 0x80000098 Interruzioni forzate
0x8000004C Watchdog 0x8000009C Azzeramento
interruzioni
0x80000050 Contatore timer2 0x800000A0 Valore della porta I/O
0x80000054 Ricarica timer2 0x800000A4 Direzione della porta
I/O
1.5.i Il controllore delle interruzioni
Il controllore di interruzione del LEON raccoglie e ordina un totale di 15 richieste di interruzione provenienti dai dispositivi interni ed esterni e le propaga alla IU.
Figura 1.12 - Schema a blocchi del controllore delle interruzioni
Quando si genera un’interruzione viene settato il bit corrispondente sull’apposito registro di attesa (interrupt unit register). I bit di questo registro sono posti in AND con quelli del registro che maschera le interruzioni (interrupt mask register) e mandato ad un selettore di priorità. Ogni interruzione può essere associata ad uno dei due livelli di priorità (livello 1=priorità maggiore, livello 0 = priorità minore), programmati in un apposito registro (interrupt level register); all’interno di ciascun livello le interruzioni hanno priorità decrescente dalla 15 alla 1. Quando la IU accetta l’interruzione il bit corrispondente nel registro delle interruzioni pendenti viene azzerato. Un’interruzione può essere forzata settando il bit corrispondente nel registro delle interruzioni forzate. Nella tabella 1.5 sono riportate le assegnazioni fatte sulle interruzioni.
INTERRUZIONE SORGENTE 15 Definita dall’utente 14 PCI 13 Definita dall’utente 12 Definita dall’utente 11 Definita dall’utente 10 Controllore di interruzione 2 9 Timer 1 8 Timer 2 7 I/O[3] 6 I/O[2] 5 I/O[1] 4 I/O[0] 3 UART 1 2 UART 2 1 Errore AHB
Tabella 1.5 – Assegnazioni per le interruzioni
1.5.l Timer e Watchdog
Il LEON implementa una unità di timer composta da 2 registri di conteggio a 24 bit, un registro a 24 bit per la generazione del segnale di watchdog e un registro a 10 bit usato come divisore di frequenza per temporizzare il decremento dei registri (prescaler). Il prescaler utilizza il clock di sistema e decrementa il suo contenuto ad ogni ciclo di clock. Una volta arrivato a 0 viene ricaricato dal registro di ricarica del prescaler e genera il segnale di decremento per i 3 registri a 24 bit. Se un timer è abilitato decrementa il suo valore (contenuto nel registro di ricarica) ad ogni impulso ricevuto e quando arriva a 0 può ricominciare il conteggio dall’inizio o disabilitarsi a seconda del valore del bit di ricarica contenuto nel registro di stato, ma in entrambi i casi viene generata un’interruzione.
Il watchdog opera in modo simile con la differenza che è sempre abilitato e al termine del conteggio produce un segnale esterno, WDOG, che può essere usato per generare il reset del sistema.
Figura 1.13 Schema a blocchi dei timers
1.5.m UARTs
Nel LEON sono disponibili due UART, uguali tra loro, per le comunicazioni seriali. Supportano trame composte da un carattere di 8 bit, un bit di parità opzionale e un
bit di stop. Per generare il bit rate (numero di bit trasmessi nell’unità di tempo) ogni UART dispone di un divisore programmabile a 12 bit ed entrambe supportano anche il controllo del flusso attraverso i segnali RTSN e CTSN. In trasmissione il dato viene trasferito in un registro di appoggio (transmitter holding register, THR) e da questo passa al registro di shift (transmitter shift register, TSR) che provvede a generare i dati seriali sulla porta di uscita TXD. Se il ricevitore della UART è abilitato cerca la prima transizione dall’uno allo zero logico e quando viene rilevata ha inizio il campionamento dei segnali di input dopo un tempo pari a metà del tempo di bit. Il bit meno significativo viene ricevuto per primo e va ad occupare la posizione meno significativa del registro di shift (receiver shift
register, RSR). Quando tutto il carattere è stato ricevuto il dato viene trasferito nel registro di appoggio (receiver holding register, RHR).
1.5.n Porta parallela di I/O
Nel LEON è disponibile una porta di I/O, parzialmente programmabile, a 32 bit. La porta è divisa in due parti: i 16 bit meno significativi sono accessibili attraverso i segnali PIO[15:0] e sono utilizzati come segnali di input/output della porta parallela mentre i 16 bit più significativi possono essere usati come dato (attraverso i segnali D[15:0]) e sono disponibili solo quando il bus di memoria è configurato per operazioni a 8 o 16 bit.
I 16 bit meno significativi possono essere programmati individualmente come ingressi o uscite nel registro di direzione. Un registro di ingresso/uscita, se letto, fornisce il valore corrente della porta di I/O (la porta viene usata come input), se scritto, fornisce il valore alla porta (la porta è usata come output). La porta di I/O può essere usata anche come ingresso per i segnali di interruzione provenienti da dispositivi esterni. Si possono generare fino a 4 livelli di interruzione (tabella 1.5) e ciascuna può essere sensibile al fronte o al livello del segnale, con polarità positiva o negativa se si programma in maniera opportuna il registro di configurazione della porta parallela di I/O.
1.5.o Il controllore di memoria
Il LEON è provvisto di un controllore programmabile del bus della memoria esterna. Il controllore agisce come slave sul bus AHB e la sua funzione viene programmata per mezzo dei registri di configurazione della memoria (MCFG1, MCFG2, MCFG3) attraverso il bus APB. Il bus di memoria supporta 4 tipi di dispositivi: PROM, SRAM, SDRAM e I/O e
può essere programmato a 8, 16 o 32 bit. Nell’implementazione scelta c’è solo una PROM di 8Mbyte e una SRAM di 1Mbyte. In generale lo spazio di memoria è mappato come mostrato nella tabella 1.6 :
Range di indirizzi Dimensione Dispositivo
0x00000000- 512M Prom
0x20000000- 512M I/O
0x40000000- 1G Sram/Sdram
Tabella 1.6 – Mappatura dello spazio di memoria
1.5.p Blocchi di protezione della scrittura
Il blocco di protezione è necessario per evitare di scrivere accidentalmente in zone di memoria e di I/O di cui si vuole salvaguardare il contenuto. Sono implementati 2 blocchi di protezione, ciascuno provvisto di un registro di controllo a 32 bit ed capace di abilitare o disabilitare accessi in scrittura a blocchi di memoria di dimensioni che vanno da 32kbyte a 1Gbyte.
1.5.q Ram AHB
Sul bus AHB è presente un modulo RAM opzionale che fornisce una memoria su chip ad elevata velocità. L’abilitazione avviene tramite il registro di configurazione e può andare da 1 a 64 Kbyte (è stata scelta una RAM di 32K), occupando gli indirizzi sul bus AHB da 0x60000000 a 0x70000000.
1.5.r Interfaccia per FPU e coprocessore
Il LEON puo’ essere configurato in modo da possedere una interfaccia generica special-purpose per un coprocessore. L'interfaccia permette al coprocessore di lavorare in parallelo all’integer unit in modo da aumentare le prestazioni. Un'istruzione per il coprocessore può essere iniziata in ogni
ciclo in cui non ci sono pendenze di dati. Quando il coprocessore ha finito, il risultato viene memorizzato in un registro del coprocessore che segnala all’integer unit di avere finito. Il protocollo di comunicazione tra integer unit e coprocessore e’ illustrato nella figura 1.15 :
Figura 1.15 – Protocollo di comunicazione tra integer unit e coprocessore
Il protocollo inizia portando a ‘1’ il segnale di avvio (cpi.start) insieme ad una istruzione valida (cpi.opcode). Gli operandi sono inviati nel successivo ciclo di clock insieme al segnale del caricamento (cpi.load). Se il coprocessore utilizzerà più di un ciclo per completare l’istruzione, deve settare a ‘1’ il segnale di occupato (cpi.busy) dal ciclo successivo a quello in cui il segnale di avvio é stato portato a ‘1’ fino al ciclo precedente a quello in cui il risultato sarà valido. Il risultato, i codici di circostanza e le informazioni di eccezione sono validi dal ciclo dopo in cui il segnale di occupato è stato portato a ‘0’ fino al nuovo segnale di inizio di una nuova istruzione. Il codice dell’istruzione ( cpi.opcode [9:0] ) è la concatenazione dei bits [ 19,13:5 ] dell'istruzione eseguita dall’integer unit del LEON. Se l'esecuzione dell’istruzione eseguita dal coprocessore deve essere interrotta prima che abbia prodotto un risultato valido (a causa di una trap dell’integer unit) il segnale cpi.flush sarà portato a ‘1’ per due cicli di clok.
Il coprocessore, in questo caso, deve essere portato alla condizione di idle. Per la FPU sono disponibili due opzioni di interfaccia:
1. un'interfaccia parallela identica all'interfaccia precedentemente descritta per il coprocessore.
2. un'interfaccia integrata dove l'istruzione di FP non viene eseguita in parallelo con istruzione di IU.
L'interfaccia per la FPU è selezionabile nella configurazione del LEON. L'interfaccia diretta per la FPU non effettua una coda per le istruzioni di calcolo in virgola mobile, il processore è interrotto durante l'esecuzione delle istruzioni di virgola mobile. Ciò significa che il bit QNE nel registro di %fsr è sempre zero e tutti i tentativi di esecuzione dell'istruzione di STDFQ genereranno un’eccezione di FPU. L'interfaccia parallela permette che le istruzioni di FPU siano eseguite in parallelo con le istruzioni di IU e interrompe il processore solo nel caso di richiesta di dati. Le caratteristiche della FPU o del coprocessore da connette al LEON vanno ovviamente realizzate tenendo conto dello standard SPARC V8.
Bibliografia
[1.1] Jiri Gaisler , “The LEON Processor User’s Manual”, version 2.3.7 August 2001
[1.2] “The SPARC Architecture Manual, version 8” SPARC International, 1992
