Differences

This shows you the differences between two versions of the page.

--- en:multiasm:cs:chapter_3_12 [2025/01/08 19:30] – ktokarz
+++ en:multiasm:cs:chapter_3_12 [2025/12/12 09:17] (current) – ktokarz
@@ Line 1: / Line 1: @@
 ====== Interrupt Controller, Interrupts ======
-An interrupt is a request to the processor to temporarily suspend the currently executing code in order to handle the event that caused the interrupt. If the request is accepted by the processor, it saves its state and performs a function named an interrupt handler or interrupt service routine (ISR). Interrupts are usually signalled by peripheral devices in a situation while they have some data to process. Often, peripheral devices do not send an interrupt signal directly to the processor, but there is an interrupt controller in the system that collects requests from various peripheral devices. The interrupt controller prioritizes the peripherals to ensure that the more important requests are handled first.
+An interrupt is a request to the processor to temporarily suspend the currently executing code in order to handle the event that caused the interrupt. If the request is accepted by the processor, it saves its state and performs a function named an interrupt handler or interrupt service routine (ISR). Interrupts are usually signalled by peripheral devices in a situation when they have some data to process. Often, peripheral devices do not send an interrupt signal directly to the processor, but there is an interrupt controller in the system that collects requests from various peripheral devices. The interrupt controller prioritises the peripherals to ensure that the more important requests are handled first.
-The interrupt signal comes asynchronously which means that it can come during execution of the instruction. Usually, the processor finishes this instruction and then calls the interrupt handler. To be able to handle interrupts the processor must implement the mechanism of storing the address of the next instruction to be executed in the interrupted code. Some implementations use the stack while some use a special register to store the returning address. The latter approach requires software support if interrupts can be nested (if the interrupt can be accepted while already in another ISR).
+From a hardware perspective, an interrupt can be signalled with the signal state or change.
+  * Level triggered - stable low or high level signals the interrupt. While the interrupt handler is finished and the interrupt signal is still active, the interrupt is signalled again.
+  * Edge-triggered - the interrupt is signalled only while there is a change in the interrupt input. The falling or rising edge of the interrupt signal.
-After finishing the interrupt subroutine processor uses the returning address to return back program control to the interrupted code.
+The interrupt signal comes asynchronously, which means that it can come during the execution of the instruction. Usually, the processor finishes this instruction and then calls the interrupt handler. To be able to handle interrupts, the processor must implement the mechanism of storing the address of the next instruction to be executed in the interrupted code. Some implementations use the stack, while others use a special register to store the return address. The latter approach requires software support if interrupts can be nested (if the interrupt can be accepted while already in another ISR).
-The Fig. {{ref>interrupt}} shows how interrupt works with stack use. The processor executes the program. When an interrupt comes it saves the return address on the stack. Next jumps to the interrupt handler. With //return// instruction processor returns to the program taking the address of an instruction to execute from the stack.
+After finishing the interrupt subroutine processor uses the returning address to return program control back to the interrupted code.
+The Fig. {{ref>interrupt}} shows how interrupt works with stack use. The processor executes the program. When an interrupt comes, it saves the return address on the stack. Next jumps to the interrupt handler. With //return// instruction processor returns to the program, taking the address of an instruction to execute from the stack.
 <figure interrupt>
@@ Line 14: / Line 18: @@
 </figure>
-===== Recognizing interrupt source =====
+===== Recognising interrupt source =====
-Fixed – microcontrollers.
+To properly handle the interrupts, the processor must recognise the source of the interrupt. Different code should be executed when the interrupt is signalled by a network controller, and different code if the source of the interrupt is a timer. The information on the interrupt source is provided to the processor by the interrupt controller or directly by the peripheral.
-every interrupt handler has its own fixed starting address.
+We can distinguish three main methods of calling a proper ISR for incoming interrupts.
-Vectored – microprocessors.
+  * Fixed – microcontrollers. Every interrupt handler has its own fixed starting address.
-one interrupt pin, peripheral sends address of handler through data bus.
+  * Vectored – microprocessors. There is one interrupt pin; the peripheral sends the address of the handler through the data bus.
-Indexed – microprocessors.
+  * Indexed – microprocessors. The peripheral sends an interrupt number. It is used as the index in the table of handlers' addresses.
-peripheral sends number of the interrupt – index in the table of handlers' addresses.
+In modern processors, interrupts can be signalled with the Message Signalled Interrupt mechanism. While the hardware needs to indicate the interrupt, it exchanges special messages through the chipset to a previously assigned memory address.
+===== Maskable and non-maskable interrupts =====
+Interrupts can be enabled or disabled. Disabling interrupts is often used for time-critical code to ensure the shortest possible execution time. Interrupts which can be disabled are named maskable interrupts. They can be disabled with the corresponding flag in the control register. In microcontrollers, there are separate bits for different interrupts.
-Maskable interrupt – can be disabled with the special flag.
+If an interrupt can not be disabled is named a non-maskable interrupt. Such interrupts are implemented for critical situations:
-Interrupts usually can be masked.
+  * memory failure
-In microcotrollers separate bits for different interrupts.
+  * power down
-Disabling interrupts for time critical code.
+  * critical hardware errors
+In microprocessors, there exists a separate non-maskable interrupt input – NMI.
-Non maskable interrupt – cannot be disabled.
-Separate interrupt input – NMI.
-Reserved usually for critical situation:
-Memory failure
-Power down
-Level triggered.
-While interrupt handler is finished and interrupt signal is still active interrupt is signalled again.
-Low level on interrput input.
-High level on interrupt input.
-Edge triggered.
-Interrupt is signalled only while there is a change on interrupt input.
-Falling edge of interrupt signal.
-Rising edge of interrupt signal.
-Software interrupts
+===== Software and internal interrupts =====
-Internal interrupts
+In some processors, it is possible to signal the interrupt by executing special instructions. They are named software interrupts and can be used to test interrupt handlers. In some operating systems (DOS, Linux), software interrupts are used to implement the mechanism of calling system functions.
-Exception – generated by abnormal behavior in some instructions (dividing by 0).
-Trap – intentionally initiated by programmer transfer control to handler routine (debugging).
-Fault – generated while detecting some errors in the program (memory protection, invalid code of operation).
+Another group of interrupts signalled by the processor itself are internal interrupts. They aren't signalled with special instructions but rather in some specific situations during normal program execution. They are called exceptions and can be divided into three groups.
+  * Faults – generated by abnormal behaviour in some instructions (e.g. dividing by 0).
+  * Traps – intentionally initiated by the programmer to transfer control to a handler routine (e.g. for debugging).
+  * Aborts – generated while detecting some serious errors in the program of computer behaviour (e.g. memory error).
+Faults are not real errors. They are often used by the operating system to perform normal operations like handling the paging mechanism.

en/multiasm/cs/chapter_3_12.1736364617.txt.gz · Last modified: 2025/01/08 19:30 by ktokarz