Personal computer/Mapping/CPU

CPU 8088

La CPU 8088 ha parallelismo 8 bit per il bus dati e 20 bit per il bus degli indirizzi. Bus dati e bus indirizzi sono multiplexati a divisione di tempo sui primi 8 bit di indirizzo. Lo spazio di I/O è separato dalla memoria ed ha dimensioni più piccole, 64K, la memoria ne ha 1M, per cui i bit necessari per un indirizzo in I/O sono 16 e corrispondono ai 16 bit più bassi dei bit di indirizzo.

       +-------\/-------+
  GND  | 1           40 |  VCC
  A14  | 2           39 |  A15
  A13  | 3           38 |  A16/S3
  A12  | 4           37 |  A17/S4
  A11  | 5           36 |  A18/S5
  A10  | 6           35 |  A19/S6
   A9  | 7           34 |  SS0
   A8  | 8           33 |  MIN/MAX*
  AD7  | 9           32 |  RD*
  AD6  | 10          31 |  HOLD  (RQGT0*)
  AD5  | 11          30 |  HOLDA (RQGT1*)
  AD4  | 12          29 |  WR*   (LOCK*)
  AD3  | 13          28 |  IO/M* (S2*)
  AD2  | 14          27 |  DT/R* (S1*)
  AD1  | 15          26 |  DEN*  (S0*)
  AD0  | 16          25 |  ALE   (QS0)
  NMI  | 17          24 |  INTA* (QS1)
  INT  | 18          23 |  TEST*
  CLK  | 19          22 |  READY
  GND  | 20          21 |  RESET
       +----------------+

Significato dei Pin

  Pin           Numero    Tipo    Descrizione
  GND           1,20       I       Ground
  VCC           40         I       Tensione di alimentazione
  AD0-AD7       9-16      I/O      Address Data Bus I primi otto bit di indirizzo sono multiplexati in divisione
                                   di tempo con gli 8 bit di del bus dati
  A8-A15        2-8,39     O       Address Bus Altri 8 bit di indirizzo
  A16/S3-A19/S6 35-38      O       Address Status Durante il primo clock sono i bit più significativi
                                   dell'indirizzo, nei clock successivi indicano un particolare stato della CPU,
                                   nelle operazioni di I/O sono sempre allo stato logico basso
  NMI           17         I       Non-Maskable Interrupt causa un interrupt di tipo 2
  INT           18         I       Interrupt Determina se il processore deve entrare in un'operazione di interrupt
  CLK           19         I       Clock
  RESET         21         I       Causa l'immediata interruzione dell'attività della CPU
  READY         22         I       Conferma che l'accesso ai dispositivi di memoria o in I/O è completato
  TEST*         23         I       Segnale attivo basso ed abilita lo stato di idle
  INTA*         24         O       Usato per leggere i segnali di conferma degli interrupt
  ALE           25         O       Address Latch Enable Quando è al segnale alto indica che i pin da 9 a 16 sono 
                                   di indirizzo, se il segnale è basso sono dei dati.
  DEN*          26         O       Data Enable Funziona come un Output Enable per gli agenti del bus dati.
                                   È un segnale attivo basso
  DT/R*         27         O       Data Transmit/Receive È usato per controllare il flusso dei dati sul bus. 
                                   Se alto indica il Data Transmit altrimenti il Data Receive
  IO/M*         28         O       Usato per distinguere l'accesso in I/O  (alto) o l'accesso in memoria (basso)
  WR*           29         O       Indica che il processore è in uno stato di scrittura (in memoria o in I/O)
  HOLD,HOLDA    30-31     I,O      Indica la presenza di un altro master sul bus
  RD*           32         O       Read Indica che la CPU sta svolgendo un ciclo di lettura (in memoria o in I/O).
                                   Segnale attivo basso
  MIN/MAX*      33         I       Minimum/Maximum Indica alla CPU di lavorare in modalità Minimum se l'ingresso 
                                   è alto, in Maximum se il segnale è basso
  SS0           34         O       Status Line Usato, insieme con IO/M* e DTR* per completare la decodifica 
                                   dello stato del corrente ciclo di bus

Nella modalità minimum i pin hanno il significato fin qui descritto. Se la CPU lavora in modalità Maximum i bit da 24 a 31 assumo il significato in parentesi. Nella modalità Maximum il bus non è più controllato dai segnali DEN* DT/R* ed ALE, ma da un integrato ( 8288 ) comandato dai segnali S0-S2.

Cicli di bus

Il bus degli indirizzi nella CPU 8088 è diviso in tre parti, la prima (AD0 -AD7) è multiplexata in divisione di tempo con il bus dati, la seconda (A8-A15) e la terza (A16-A19) anch'essa multiplexata. Questa strategia permette l'uso più efficiente dei pin del processore, tuttavia richiede delle operazioni aggiuntive per il demultiplex.

Ogni ciclo di bus consiste almeno di quattro parti della lunghezza di un clock (CLK) denominate T1 T2 T3 T4.

L'indirizzo, sia per un ciclo di lettura che di scrittura, viene emesso durante T1, la lettura o scrittura dei dati avviene in T3, T4 e T2 servono principalmente per cambiare la direzione del bus durante le operazioni in modo da avere in T1 e T3 dei segnali stabili e non flottanti.

Nel caso in cui una lettura non sia completata tra lo stato T3 e lo stato T4 vengono aggiunti degli stati di wait TW. Ogni stato di wait è della stessa durata di un ciclo di CLK. Il segnale per indicare alla CPU l'avvenuta lettura è il READY.

Durante T1 viene emesso il segnale ALE (Address Latch Enable) ad indicare che la prima parte del bus indirizzi corrisponde effettivamente ad un indirizzo e non al bus dati.

Nel caso di operazioni I/O lo spazio di indirizzamento è più piccolo di quello della memoria, è infatti da 64K, ovvero bastano 16 bit di indirizzo, vengono usati a questo scopo i pin A0-A15, i bit A16-A19 sono al valore logico basso durante le operazioni di lettura/scrittura in I/O.

Lettura

Il ciclo di lettura inizia in T1 con il segnale alto ALE ed è individuato dal segnale DT/R* basso.

Durante T2 viene rimosso l'indirizzo dal bus dati che va in uno stato di alta impedenza. Viene inoltre attivato il segnale RD (essendo attivo basso diventa zero) che causa l'attivazione del driver del bus dati da parte del dispositivo indirizzato. In base al valore di IO/M* il segnale di RD* diventa sul bus comandi un MRDC* o un IORDC*.

Dopo un certo periodo (T3 ed eventuali stati TW) saranno disponibili sul bus dei dati validi e il dispositivo indirizzato attiverà il segnale di READY. Gli stati TW sono funzionalmente uguali ad uno stato T3, durante il clock di salita il processore legge il segnale READY, se questo è basso verrà aggiunto uno stato TW, se invece è alto il prossimo stato sarà T4.

In T4 il processore legge il bus dati (AD0-AD7) e riporta il RD* ad alto, immediatamente il dispositivo indirizzato entra in 3-state.

Scrittura

Anche un ciclo di scrittura comincia con l'attivazione di ALE e l'emissione dell'indirizzo, questa volta il DT/R* è alto ad indicare un Data Transmit ovvero una scrittura.

Durante T2, subito dopo l'emissione dell'indirizzo il processore presenta sul bus dati (AD0-AD7) i bit da scrivere nel dispositivo indirizzato. Questi dati rimangono validi fino almeno a metà dello stato T4.

Durante T2 T3 e TW il processore abilita il segnale WR* (lo porta quindi al livello basso). Questo segnale viene attivato subito durante T2 a differenza del ciclo di lettura dove il RD* viene leggermente ritardato per permettere al bus la transizione.

8284

I segnali di CLK READY e RESET a causa delle loro specifiche restrittive vengono generati da un apposito integrato, l' 8284

     +-------------------+
 --> | CSYNC          X1 | <--
 <-- | PCLK           X2 | <--
 --> | AEN1*      ASYNC* | <--
 --> | RDY1          EFI | <--
 <-- | READY        F/C* | <--
 --> | RDY2          OSC | -->
 --> | AEN2*        RES* | <--
 <-- | CLK         RESET | -->
     +-------------------+

Dal punto di vista logico l'integrato 8284 può essere diviso in tre blocchi funzionali:

• Ready Generator Dati in ingresso due segnali di ready con temporizzazioni diverse ( RDY1 e RDY2 ) i segnali AEN1* e AEN2* selezionano i rispettivi segnali di ready. Il segnale attivo basso di ASYNC* specifica se il segnale di ready deve essere sincronizzato al clock di discesa o rimanere asincrono. L'uscita di questo blocco è il segnale READY.

• Clock Generator Il clock può essere generato sia internamente (tramite i segnali che arrivano da due oscillatori collegati ad X1 ed X2) che esternamente, ad esempio tramite un altro 8284, a decidere quale modalità usare è il segnale F/C*, nel caso di sincronizzazione esterna vengono utilizzati come ingressi EFI e CSYNC. I segnali in uscita sono CLK il clock da usare per la cpu con un duty cycle del 30%, PCLK un segnale con frequenza metà di quella del CLK e duty cycle del 50%, OSC l'output da collegare ad un altro 8284 come sincronizzazione esternza.

• Reset Generator Il segnale di reset va sincronizzato con il fronte di discesa del clock per cui il reset generator ha l'unico scopo di sincronizzare il segnale RES* ricevuto in ingresso e presentare in uscita il segnale RESET

I segnali READY CLK e RESET vengono collegati direttamente in ingresso alla CPU 8088 sui rispettivi pin.

Circuito per la generazione del Ready

L'8284 in base ai possibili segnali ready di ingresso deve generare un segnale di ready con la giusta temporizzazione.

Ipotizziamo di poter dividere tutti i dispositivi in due gruppi che richiedono rispettivamente 2 e 3 stati di wait per completare l'accesso. Per generare i due segnali di ready RDY1 e RDY2 utilizziamo uno shift register a n uscite Q0, Q1, ..., Qn con ingressi il segnale di CLK e AEN. Lo shift register a partire dal primo clock successivo alla ricezione del segnale ALE attiva l'uscita Q0, al clock ancora successivo Q1 e così via. Per il nostro sistema i segnali utili sono Q2 e Q3 che andranno collegati all'8284 come RDY1 e RDY2.

La generazione dei segnali di selezione AEN1* e AEN2* dipende da quali sono i dispositivi che richiedono 2 piuttosto che 3 stati di wait. Se tutti i dispositivi in memoria richiedono due clock e quelli di I/O 3 allora

 RDY1  <- Q2
 AEN1* <- IO/M* ; se accedo in memoria IO/M* sarà basso e quindi attiva RDY1 essendo AEN attivo basso
 RDY2  <- Q3
 AEN2* <- !IO/M*; negazione di IO/M*

Se invece i dispositivi che richiedono 2 stati di wait sono gli indirizzi di memoria mappati nei 512K alti e quelli che richiedono 3 stati di wait sono nei 512K bassi e in I/O allora

 RDY1  <- Q2
 AEN1* <- IO/M* + !BA19  ; per attivare il RDY1, AEN1 deve valere zero e quindi devo 
                           accedere in memoria (IO/M = 0) e nei 512K alti (BA19 = 1, devo negarlo)
 RDY2  <- Q3
 AEN2* <- !(IO/M*) * BA19; se accedo in I/O !(IO/M*) vale 0 e quindi seleziono REDY2
                           se accedo in memoria !(IO/M*) vale 1 ed ho bisogno che BA19 valga 0

Supponiamo invece di avere tre gruppi di dispositivi che richiedano rispettivamente 0, 2 e 3 stati di wait, selezionati dai segnali SEL1*, SEL2* e SEL3* allora

 RDY1  <- Q0
 AEN1* <- SEL1*
 RDY2  <- (Q2 * !SEL2*) + (Q3 * SEL2*)
                ;se SEL2* e basso al secondo clock Q2 * !SEL2* è alto quindi RDY1 = Q2
                 se SEL2* è alto il primo termine vale sempre zero, quindi RDY2 = Q3 (SEL2* = 1)
 AEN2* <- SEL2* * SEL3*

Calcolo degli stati di wait

Per il corretto funzionamento di un ciclo di lettura è necessario che la CPU campioni i dati sul registro MDR, e che il ciclo sia sufficientemente grande da permettere alla memoria di presentare dei dati validi sul bus, definendo

 $T_{sample}$ intervallo di tempo tra l'inizio del ciclo di lettura e il campionamento dei dati su MDR
 $T_{CLCL}$ tempo di clock

Dato che la CPU legge i dati dalla memoria al clock T3 (il terzo) oppure, se presenti, all'ultimo TW, indicando con n il numero di stati di wait, vale la formula
$T_{sample}=(3+n)*T_{CLCL}$

Affinché la CPU campioni correttamente i dati devono essere validi,
$T_{sample}\geq T_{datavalid}$
vanno quindi considerati i percorsi che seguono indirizzi e segnali di comando prima che i dati siano validi

Percorso degli indirizzi

Con

  $T_{datavalid}$  tempo necessario affinché i dati siano validi
  $T_{CLAV}$    ritardo per avere in uscita alla CPU indirizzi validi
  $T_{373}$      ritardo introdotto dal blocco 373
  $T_{DEC}$     ritardo per la decodifica degli indirizzi
  $T_{acc}$      tempo di accesso alla memoria
  $T_{245}$      ritardo introdotto dal blocco 245
  $T_{DVCL}$    tempo per il set-up del registro MDR da parte della CPU

risulta $T_{datavalid}=T_{CLAV}+T_{373}+T_{DEC}+T_{acc}+T_{245}+T_{DVCL}$

Percorso dei comandi

Con

  $T_{datavalid}$  tempo necessario affinché i dati siano validi
  $T_{CLCL}$    un clock, necessario perché RD* si attiva in T2
  $T_{CLRL}$    ritardo di attivazione del comando RD*
  $T_{oe}$       ritardo introdotto dalla memoria alla ricezione di RD*
  $T_{245}$      ritardo introdotto dal blocco 245
  $T_{DVCL}$    tempo per il set-up del registro MDR da parte della CPU

risulta $T_{datavalid}=T_{CLCL}+T_{CLRL}+T_{oe}+T_{245}+T_{DVCL}$

Il tempo di data valid da prendere in considerazione per il calcolo del numero di stati di wait necessari è dato dal peggiore dei due percorsi.

Esempio di calcolo

Consideriamo un processore 8088 ad 8Mhz ( $T_{CLCL}=1/{freq}=125ns$ ) con i seguenti valori

  $T_{acc}$ = 250 ns
  $T_{CLAV}$ =  60 ns
  $T_{CLRL}$ = 100 ns
  $T_{373}$ =  18 ns
  $T_{245}$ =  10 ns
  $T_{DEC}$ =  30 ns
  $T_{DVCL}$ =  20 ns
  $T_{oe}$ =  60 ns

Il tempo minimo per avere dati validi seguendo il percorso degli indirizzi è

  $(3+n)*T_{CLCL}\geq T_{CLAV}+T_{373}+T_{DEC}+T_{acc}+T_{245}+T_{DVCL}$
  $(3+n)*125\geq 60+18+30+250+10+20=388$

Tempo che richiede uno stato di wait

Seguendo il percorso dei comandi

  $(3+n)*T_{CLCL}\geq T_{CLCL}+T_{CLRL}+T_{oe}+T_{245}+T_{DVCL}$
  $(3+n)*125\geq 125+100+60+10+20=315$

Il tempo calcolato seguendo il percorso dei comandi non richiede stati di wait, che tuttavia sono richiesti per soddisfare il tempo di campionamento necessario seguendo il percorso degli indirizzi.

Temporizzazioni

CPU 8088 dal datasheet Intel

          5Mhz    8Mhz
  $T_{CLCL}$   200     125    ns
  $T_{CLAV}$   110      60    ns
  $T_{DVCL}$    30      20    ns
  $T_{CLRL}$   165     100    ns

Per 373, 245 i tempi sono tipicamente

  $T_{373}$    18 ns
  $T_{245}$    10 ns

Un valore tipico per il tempo di decodifica è

  $T_{DEC}$    30 ns

I tempi di accesso ed oe dipendono fortemente dal tipo di memoria utilizzato