Come funzionano gli interrupt su Intel 8080? Ho cercato su Google e nella documentazione ufficiale di Intel (197X), e ho trovato solo una piccola descrizione a riguardo. Ho bisogno di una spiegazione dettagliata su di esso, per emulare questa CPU.Come funzionano gli interrupt su Intel 8080?
Finalmente lo trovo!
Creo una variabile denominata bus in cui passa l'opcode di interruzione. Poi, ho chiamato una funzione per gestire l'interruzione:
void i8080::interruption()
{
// only for RST
cycles -= cycles_table[bus];
instruction[bus]();
INT = false;
}
INT è vero quando ha bisogno di un'interruzione. Le istruzioni EI e DI gestiscono INTE.
Quando INT e INTE sono vere, viene eseguita l'interruzione.
I puntatori di funzione ai gestori di interrupt sono memorizzati nella memoria insufficiente. Circa 32 dei primi indirizzi sono interruzioni hardware: hardware attivato.
I successivi 32 indirizzi sono attivabili dall'utente, vengono chiamati interrupt software. Sono attivati da un'istruzione INT.
Il parametro su INT è l'interrupt software numero vettore, che sarà l'interrupt chiamato.
Sarà necessario utilizzare l'istruzione IRET per tornare dagli interrupt.
È probabile che si debbano disabilitare anche gli interrupt come prima cosa quando si inserisce un interrupt.
Per ulteriori dettagli, fare riferimento alla documentazione relativa al modello di processore specifico, che tende a variare ampiamente.
Questo descrive l'8086, non l'8080. –
L'8080 dipendeva dall'hardware esterno per controllare la gestione degli interrupt, quindi è impossibile generalizzare. Cercare informazioni sui controller di interrupt Intel 8214 o 8259.
Ma viene dal bus? – Facon
Un interrupt è un modo di interrompere la CPU con una notifica per gestire qualcosa d'altro, non sono certo del 8080 di chip Intel, ma dalla mia esperienza, il modo migliore per descrivere un interrupt è questo:
Il CS:IP (Segmento codice: Puntatore istruzioni) si trova su questa istruzione all'indirizzo di memoria 0x0000: 0020, come esempio per spiegarlo usando le istruzioni Intel 8086, l'assemblatore non ha senso e non ha alcun significato reale ... le istruzioni sono fantasiosi
0x0000:001C MOV AH, 07 0x0000:001D CMP AH, 0 0x0000:001E JNZ 0x0020 0x0000:001F MOV BX, 20 0x0000:0020 MOV CH, 10 ; CS:IP is pointing here 0x0000:0021 INT 0x15
Quando CS: IP punta alla riga successiva e viene emesso un esadecimale 15 INT, questo è ciò che accade, la CPU inserisce i registri e i flag nello stack e quindi esegue il codice a 0x1000: 0100, che fornisce INT 15 come un esempio
0x1000:0100 PUSH AX 0x1000:0101 PUSH BX 0x1000:0102 PUSH CX 0x1000:0103 PUSH DX 0x1000:0104 PUSHF 0x1000:0105 MOV ES, CS 0x1000:0106 INC AX 0x1000:0107 .... 0x1000:014B IRET
Poi, quando il CS: IP colpisce su istruzione 0x1000: 014B, un IRET (interrupt ritorno), che salta fuori tutti i registri e ripristinare lo stato, viene rilasciato e quando viene eseguito CS della CPU : IP indica nuovamente qui, dopo l'istruzione a 0x0000: 0021.
0x0000:0022 CMP AX, 0 0x0000:0023 ....
come la CPU sa dove per passare a un particolare offset viene basato sulla tabella vettore di interrupt, questa tabella vettore di interruzione è impostato dal BIOS in una posizione particolare nel BIOS, sarebbe simile a questa:
INT BIOS's LOCATION OF INSTRUCTION POINTER --- -------------------------------------- 0 0x3000 1 0x2000 .. .... 15 0x1000 <--- THIS IS HOW THE CPU KNOWS WHERE TO JUMP TO
quel tavolo è memorizzato nel BIOS e quando viene eseguito il INT 15, il BIOS, sarà reindirizzare il CS: IP alla posizione nel BIOS per eseguire il codice di servizio che gestisce l'interrupt.
Torna ai vecchi tempi, sotto Turbo C, c'era un modo per ignorare le routine di tabella vettore di interrupt con le proprie funzioni di gestione interrupt utilizzando le funzioni setvect e getvect in cui i gestori di interrupt effettivi sono stati nuovamente verso il proprio codice.
Spero di averlo spiegato abbastanza bene, ok, non è Intel 8080, ma questo è ciò che capisco, e sarei sicuro che il concetto è lo stesso per quel chip come la famiglia di chipset Intel x86.
Bella spiegazione! Grazie. – Leonardo
questo è per l'8086, non lo 080 –
L'8080 ha una linea di interruzione (pin 14). Tutte le periferiche sono collegate a questo pin, di solito in una configurazione "wire-OR" (ovvero, le uscite di richiesta di interrupt sono open-collector e il pin di interrupt viene tirato in alto con un resistore). Internamente, il processore ha un bit di abilitazione interrupt. Due istruzioni, EI e DI, impostano e cancellano questo bit. L'intero sistema di interrupt viene quindi attivato o disattivato, i singoli interrupt non possono essere mascherati sul "nudo" 8080. Quando un dispositivo emette un interrupt, il processore risponde con un segnale di "Interrupt Acknowledge" (~ INTA). Questo segnale ha la stessa temporizzazione del segnale "Memory Read" (~ MEMR) e ha lo scopo di attivare il dispositivo periferico per inserire un'istruzione "Restart" sul bus dati. Il segnale di conferma di interruzione è fondamentalmente un ciclo di recupero delle istruzioni, si verifica solo in risposta a un interrupt.
Esistono otto istruzioni di riavvio, RST 0 - RST 7. RST 7 è codice "0xFF". Le istruzioni di riavvio fanno in modo che il processore spinga il contatore del programma sullo stack e inizi l'esecuzione in una posizione vettoriale di riavvio. RST 0 vettori a 0x0000, RST 1 vettori a 0x0008, RST 2 vettori a 0x0010 e così via. Riavvia 7 vettori su 0x0038. Questi indirizzi vettoriali sono destinati a contenere codice eseguibile, generalmente un'istruzione di salto a una routine di servizio di interruzione. La routine di servizio interrupt impilerà tutti i registri che utilizza, eseguirà le necessarie funzioni di I/O, disimpegnerà tutti i registri e tornerà al programma principale tramite la stessa istruzione di ritorno che termina le subroutine (RET, opcode 0xC9).
Le istruzioni di riavvio sono opcodes effettivi, nel senso che faranno la stessa cosa se vengono prelevati dalla memoria durante l'esecuzione del programma. Era conveniente usare il riavvio 7 come "riavvio a caldo" per un programma monitor/debugger della tastiera perché le EPROM in anticipo contenevano generalmente 0xFF in ogni posizione vuota. Se stavi eseguendo una EPROM vuota, significava che qualcosa era andato storto e che probabilmente volevi tornare sul monitor comunque.
Nota che i vettori RST 0 nella stessa posizione di memoria di RESET, entrambi iniziano a eseguire a 0x0000. Ma RST 0 lascia un indirizzo di ritorno nello stack. In un certo senso, RESET può essere pensato come l'unico interrupt non mascherabile che l'8080 ha avuto.
Un segnale di interrupt cancella anche il bit di interrupt in modo che una routine di servizio di interrupt debba eseguire un'istruzione EI, generalmente immediatamente prima del RET. In caso contrario, il sistema risponderà a uno e solo un evento di interrupt.
CP/M ha riservato i primi 256 byte di memoria per l'utilizzo del sistema e quella mappa vettoriale di interrupt ha utilizzato i primi 64 byte (8 byte per istruzione Restart).Sui sistemi CP/M, la RAM partiva da 0x0000 e ogni ROM viveva nella parte superiore della memoria. Questi sistemi utilizzavano una qualche forma di commutazione intelligente del banco per passare in una EPROM o qualcosa subito dopo un RESET per fornire un'istruzione JUMP alla ROM di sistema in modo che potesse iniziare la sequenza di avvio. I sistemi che avevano la ROM all'estremità inferiore della mappa di memoria programmavano le istruzioni JUMP ai vettori situati nella RAM nei primi 64 byte. Questi sistemi dovevano inizializzare quei vettori RAM all'avvio.
Se è una variabile "dove va l'opcode", perché non chiamarlo "opcode"? –
opcode è usato come tipo di dati, comunque, come vedo, l'opcode di interruzione va al bus esterno di 8080, quindi penso che fosse OK. Grazie a tutti! – Facon