Английская Википедия:Interrupts in 65xx processors

Шаблон:Redirect The 65xx family of microprocessors, consisting of the MOS Technology 6502 and its derivatives, the WDC 65C02, WDC 65C802 and WDC 65C816, and CSG 65CE02, all handle interrupts in a similar fashion. There are three hardware interrupt signals common to all 65xx processors and one software interrupt, the Шаблон:Mono instruction. The WDC 65C816 adds a fourth hardware interrupt—Шаблон:Mono, useful for implementing virtual memory architectures—and the Шаблон:Mono software interrupt instruction (also present in the 65C802), intended for use in a system with a coprocessor of some type (e.g., a floating-point processor).^[1]^[2]

Interrupt types

65xx interrupt vector locations^[2]^[3]
Interrupt	Vector (hexadecimal)
Interrupt	LSB	MSB
Шаблон:Mono/Шаблон:Mono	FFFE	FFFF
Шаблон:Mono	FFFC	FFFD
Шаблон:Mono	FFFA	FFFB
Шаблон:Mono Шаблон:Refn	FFF8	FFF9
Шаблон:Mono Шаблон:Refn	FFF4	FFF5

The hardware interrupt signals are all active low, and are as follows:^[1]

RESET: a reset signal, level-triggered
NMI: a non-maskable interrupt, edge-triggered
IRQ: a maskable interrupt, level-triggered
ABORT: a special-purpose, non-maskable interrupt (65C816 only, see below), level-triggered

The detection of a Шаблон:Mono signal causes the processor to enter a system initialization period of six clock cycles, after which it sets the interrupt request disable flag in the status register and loads the program counter with the values stored at the processor initialization vector (Шаблон:Mono–Шаблон:Mono) before commencing execution.^[1] If operating in native mode, the 65C816/65C802 are switched back to emulation mode and stay there until returned to native mode under software control.

65C816/65C802 native mode interrupt vector locations^[2]
Interrupt	Vector (hexadecimal)
Interrupt	LSB	MSB
Шаблон:Mono	00FFEE	00FFEF
Шаблон:Mono	NoneШаблон:Refn
Шаблон:Mono	00FFEA	00FFEB
Шаблон:Mono^{[nb 1]}	00FFE8	00FFE9
Шаблон:Mono	00FFE6	00FFE7
Шаблон:Mono^{[nb 2]}	00FFE4	00FFE5

The detection of an Шаблон:Mono or Шаблон:Mono signal, as well as the execution of a Шаблон:Mono instruction, will cause the same overall sequence of events, which are, in order:^[1]^[3]

The processor completes the current instruction and updates registers or memory as required before responding to the interrupt.
65C816/65C802 when operating in native mode: The program bank register (Шаблон:Mono, the Шаблон:Mono part of the address bus) is pushed onto the hardware stack.
The most significant byte (MSB) of the program counter (Шаблон:Mono) is pushed onto the stack.
The least significant byte (LSB) of the program counter is pushed onto the stack.
The status register (Шаблон:Mono) is pushed onto the stack.
The interrupt disable flag is set in the status register.
65C816/65C802: Шаблон:Mono is loaded with Шаблон:Mono.
Шаблон:Mono is loaded from the relevant vector (see tables).

The behavior of the 65C816 when Шаблон:Mono is asserted differs in some respects from the above description and is separately discussed below.

Note that the processor does not push the accumulator and index registers on to the stack—code in the interrupt handler must perform that task, as well as restore the registers at the termination of interrupt processing, as necessary. Also note that the vector for Шаблон:Mono is the same as that for Шаблон:Mono in all eight bit 65xx processors, as well as in the 65C802/65C816 when operating in emulation mode. When operating in native mode, the 65C802/65C816 provide separate vectors for Шаблон:Mono and Шаблон:Mono.^[4]

When set, the interrupt request disable flag (the Шаблон:Mono bit in the status register) will disable detection of the Шаблон:Mono signal, but will have no effect on any other interrupts (however, see below section on the Шаблон:Mono instruction implemented in WDC CMOS processors). Additionally, with the 65(c)02 or the 65C816/65C802 operating in emulation mode, the copy of the status register that is pushed on to the stack will have the Шаблон:Mono flag set if a Шаблон:Mono (software interrupt) was the cause of the interrupt, or cleared if an Шаблон:Mono was the cause.Шаблон:Refn Hence the interrupt service routine must retrieve a copy of the saved status register from where it was pushed onto the stack and check the status of the Шаблон:Mono flag in order to distinguish between an Шаблон:Mono and a Шаблон:Mono.^[1]^[2]^[4] This requirement is eliminated when operating the 65C802/65C816 in native mode, due to the separate vectors for the two interrupt types.^[2]

Шаблон:Mono interrupt

The 65C816's Шаблон:Mono interrupt input is intended to provide the means to redirect program execution when a hardware exception is detected, such as a page fault or a memory access violation. Hence the processor's response when the Шаблон:Mono input is asserted (negated) is different from when Шаблон:Mono and/or Шаблон:Mono are asserted. Also, achieving correct operation in response to Шаблон:Mono requires that the interrupt occur at the proper time during the machine cycle, whereas no such requirement exists for Шаблон:Mono or Шаблон:Mono.

When Шаблон:Mono is asserted during a valid memory cycle, that is, when the processor has asserted the Шаблон:Mono and/or Шаблон:Mono status outputs, the following sequence of events will occur:^[2]

The processor completes the current instruction but does not change the registers or memory in any way—the computational results of the completed instruction are discarded. An abort interrupt does not literally abort an instruction.^[2]
The program bank (Шаблон:Mono, see above) is pushed to the stack.
The most significant byte (MSB) of the aborted instruction's address is pushed onto the stack.
The least significant byte (LSB) of the aborted instruction's address is pushed onto the stack.
The status register is pushed onto the stack.
The interrupt disable flag is set in the status register.
Шаблон:Mono is loaded with Шаблон:Mono.
The program counter is loaded from the Шаблон:Mono vector (see tables).

As the address pushed to the stack is that of the aborted instruction rather than the contents of the program counter, executing an Шаблон:Mono (ReTurn from Interrupt) following an Шаблон:Mono interrupt will cause the processor to return to the aborted instruction, rather than the next instruction, as would be the case with the other interrupts.

In order for the processor to correctly respond to an abort, system logic must assert (negate) the Шаблон:Mono input as soon as a valid address has been placed on the bus and it has been determined that the address constitutes a page fault, memory access violation or other anomaly (e.g., attempted execution of a privileged instruction). Hence the logic must not assert Шаблон:Mono until the processor has asserted the Шаблон:Mono or Шаблон:Mono signals. Also, Шаблон:Mono must remain asserted until the fall of the phase-two clock and then be immediately released. If these timing constraints are not observed, the abort interrupt handler itself may be aborted, causing registers and/or memory to be changed in a possibly-undefined manner.^[2]

Interrupt anomalies

In the NMOS 6502 and derivatives (e.g., 6510), the simultaneous assertion of a hardware interrupt line and execution of Шаблон:Mono was not accounted for in the design—the Шаблон:Mono instruction will be ignored in such a case. Also, the status of the decimal mode flag in the processor status register is unchanged following an interrupt of any kind. This behavior can potentially result in a difficult to locate bug in the interrupt handler if decimal mode happens to be enabled at the time of an interrupt. These anomalies were corrected in all CMOS versions of the processor.^[2]

Interrupt handler considerations

A well-designed and succinct interrupt handler or interrupt service routine (ISR) will not only expeditiously service any event that causes an interrupt, it will do so without interfering in any way with the interrupted foreground task—the ISR must be "transparent" to the interrupted task (although exceptions may apply in specialized cases). This means that the ISR must preserve the microprocessor (MPU) state and not disturb anything in memory that it is not supposed to disturb. Additionally, the ISR should be fully reentrant, meaning that if two interrupts arrive in close succession, the ISR will be able to resume processing the first interrupt after the second one has been serviced. Reentrancy is typically achieved by using only the MPU hardware stack for storage (though there are other possible methods).

Preserving the MPU state means that the ISR must assure that whatever values were in the MPU registers at the time of the interrupt are there when the ISR terminates. A part of the preservation process is automatically handled by the MPU when it acknowledges the interrupt, as it will push the program counter (and program bank in the 65C816/65C802) and status register to the stack prior to executing the ISR. At the completion of the ISR, when the Шаблон:Mono instruction is executed, the MPU will reverse the process. No member of the 65xx family pushes any other registers to the stack.^[2]

In most ISRs, the accumulator and/or index registers must be preserved to assure transparency and later restored as the final steps prior to executing Шаблон:Mono. In the case of the 65C816/65C802, consideration must be given to whether it is being operated in emulation or native mode at the time of the interrupt. If the latter, it may also be necessary to preserve the data bank (Шаблон:Mono) and direct (zero) page (Шаблон:Mono) registers to guarantee transparency. Also, a 65C816 native mode operating system may well use a different stack location than the application software, which means the ISR would have to preserve and subsequently restore the stack pointer (Шаблон:Mono). Further complicating matters with the 65C816/65C802 is that the sizes of the accumulator and index registers may be either 8 or 16 bits when operating in native mode, requiring that their sizes be preserved for later restoration.^[2]

The methods by which the MPU state is preserved and restored within an ISR will vary with the different versions of the 65xx family. For NMOS processors (e.g., 6502, 6510, 8502, etc.), there can be only one method by which the accumulator and index registers are preserved, as only the accumulator can be pushed to and pulled from the stack.^[5] Therefore, the following ISR entry code is typical:

        PHA                     ; save accumulator
        TXA
        PHA                     ; save X-register
        TYA
        PHA                     ; save Y-register
        CLD                     ; ensure binary mode by clearing decimal flag

The Шаблон:Mono instruction is necessary because, as previously noted, NMOS versions of the 6502 do not clear the Шаблон:Mono (decimal mode) flag in the status register when an interrupt occurs.

Once the accumulator and index registers have been preserved, the ISR can use them as needed. When the ISR has concluded its work, it would restore the registers and then resume the interrupted foreground task. Again, the following NMOS code is typical:

        PLA
        TAY                     ; restore Y-register
        PLA
        TAX                     ; restore X-register
        PLA                     ; restore accumulator
        RTI                     ; resume interrupted task

A consequence of the Шаблон:Mono instruction is the MPU will return to decimal mode if that was its state at the time of the interrupt.^[5]

The 65C02, and the 65C816/65C802 when operating in emulation mode, require less code, as they are able to push and pull the index registers without using the accumulator as an intermediary.^[2] They also automatically clear decimal mode before executing the ISR.^[2] The following is typical:

        PHA                     ; save accumulator
        PHX                     ; save X-register
        PHY                     ; save Y-register

Upon finishing up, the ISR would reverse the process:

        PLY                     ; restore Y-register
        PLX                     ; restore X-register
        PLA                     ; restore accumulator
        RTI                     ; resume interrupted task

As previously stated, there is a little more complexity with the 65C816/65C802 when operating in native mode due to the variable register sizes and the necessity of accounting for the Шаблон:Mono and Шаблон:Mono registers. In the case of the index registers, they may be pushed without regard to their sizes, as changing sizes automatically sets the most significant byte (MSB) in these registers to zero and no data will be lost when the pushed value is restored, provided the index registers are the same size they were when pushed.^[2]

The accumulator, however, is really two registers: designated Шаблон:Mono and Шаблон:Mono.^[2] Pushing the accumulator when it is set to 8 bits will not preserve Шаблон:Mono,^[2] which could result in a loss of transparency should the ISR change Шаблон:Mono in any way. Therefore, the accumulator must always be set to 16 bits before being pushed or pulled if the ISR will be using Шаблон:Mono. It is also more efficient to set the index registers to 16 bits before pushing them. Otherwise, the ISR has to then push an extra copy of the status register so it can restore the register sizes prior to pulling them from the stack.

For most ISRs, the following entry code will achieve the goal of transparency:

        PHB                     ; save current data bank
        PHD                     ; save direct page pointer
        REP #%00110000          ; select 16 bit registers
        PHA                     ; save accumulator
        PHX                     ; save X-register
        PHY                     ; save Y-register

In the above code fragment, the symbol Шаблон:Mono is MOS Technology and WDC standard assembly language syntax for a bitwise operand.

If the ISR has its own assigned stack location, preservation of the stack pointer (Шаблон:Mono) must occur in memory after the above pushes have occurred—it should be apparent why this is so. The following code, added to the above sequence, would handle this requirement:

        TSC                     ; copy stack pointer to accumulator
        STA stkptr              ; save somewhere in safe RAM
        LDA isrptr              ; get ISR's stack pointer &...
        TCS                     ; set new stack location

At the completion of the ISR, the above processes would be reversed as follows:

        REP #%00110000          ; select 16 bit registers
        TSC                     ; save ISR's SP...
        STA isrptr              ; for subsequent use
        LDA isstkptr            ; get foreground task's SP &...
        TCS                     ; set it
        PLY                     ; restore Y-register
        PLX                     ; restore X-register
        PLA                     ; restore accumulator
        PLD                     ; restore direct page pointer
        PLB                     ; restore current data bank
        RTI                     ; resume interrupted task

Note that upon executing Шаблон:Mono, the 65C816/65C802 will automatically restore the register sizes to what they were when the interrupt occurred, since pulling the previously–saved status register sets or clears both register size bits to what they were at the time of the interrupt.^[2]

While it is possible to switch the 65C816/65C802 from native mode to emulation mode within an ISR, such is fraught with peril.^[2] In addition to forcing the accumulator and index registers to 8 bits (causing a loss of the most significant byte in the index registers), entering emulation mode will truncate the stack pointer to 8 bits and relocate the stack itself to page 1 RAM.^[2] The result is the stack that existed at the time of the interrupt will be inaccessible unless it was also in page 1 RAM and no larger than 256 bytes. In general, mode switching while servicing an interrupt is not a recommended procedure, but may be necessary in specific operating environments.

Using Шаблон:Mono and Шаблон:Mono

As previously noted, Шаблон:Mono and Шаблон:Mono are software interrupts and, as such, may be used in a variety of ways to implement system functions.

A historical use of Шаблон:Mono has been to assist in patching PROMs when bugs were discovered in a system's firmware. A typical technique often used during firmware development was to arrange for the Шаблон:Mono vector to point to an unprogrammed "patch area" in the PROM. In the event a bug was discovered, patching would be accomplished by "blowing" all of the fuses at the address where the faulty instruction was located, thus changing the instruction's opcode to Шаблон:Mono. Upon executing the resulting Шаблон:Mono, the MPU would be redirected to the patch area, into which suitable patch code would be written. Often, the patch area code started by "sniffing the stack" to determine the address at which the bug was encountered, potentially allowing for the presence of more than one patch in the PROM. The use of Шаблон:Mono for PROM patching diminished once EPROMs and EEPROMs became commonly available.

Another use of Шаблон:Mono in software development is as a debugging aid in conjunction with a machine language monitor. By overwriting an opcode with Шаблон:Mono (Шаблон:Mono) and directing the Шаблон:Mono hardware vector to the entry point of the monitor, one can cause a program to halt at any desired point, allowing the monitor to take control. At that time, one may examine memory, view the processor's register values, patch code, etc. Debugging, as advocated by Kuckes and Thompson, can be facilitated by liberally sprinkling one's code with Шаблон:Mono instructions (opcode Шаблон:Mono) that can be replaced by Шаблон:Mono instructions without altering the actual behaviour of the program being debugged.^[5]^[6]^[7]

A characteristic of the Шаблон:Mono and Шаблон:Mono instructions is that the processor treats either of them as a two byte instruction: the opcode itself and the following byte, which is referred to as the "signature."^[2] Upon execution of Шаблон:Mono or Шаблон:Mono, the processor will add two to the program counter prior to pushing it to the stack. Hence when Шаблон:Mono (ReTurn from Interrupt) is executed, the interrupted program will continue at the address immediately following the signature. If Шаблон:Mono is used as a debugging device, the program counter may have to be adjusted to point to the signature in order for execution to resume where expected. Alternatively, a Шаблон:Mono may be inserted as a signature "placeholder," in which case no program counter adjustment will be required.

The fact that Шаблон:Mono and Шаблон:Mono double-increment the program counter before pushing it to the stack facilitates the technique of treating them as supervisor call instructions, as found on some mainframe computers. The usual procedure is to treat the signature as an operating system service index. The operating system Шаблон:Mono or Шаблон:Mono handler would retrieve the value of the program counter pushed to the stack, decrement it and read from the resulting memory location to get the signature.^[8]^[9] After converting the signature to a zero-based index, a simple lookup table can be consulted to load the program counter with the address of the proper service routine. Upon completion of the service routine, the Шаблон:Mono instruction would be used to return control to the program that made the operating system call. Note that the signature for Шаблон:Mono may be any value, whereas the signature for Шаблон:Mono should be limited to the range Шаблон:Mono-Шаблон:Mono.^[2]

The use of Шаблон:Mono and/or Шаблон:Mono to request an operating system service means user applications do not have to know the entry address of each operating system function, only the correct signature byte to invoke the desired operation. Hence relocation of the operating system in memory will not break compatibility with existing user applications. Also, as executing Шаблон:Mono or Шаблон:Mono always vectors the processor to the same address, simple code may be used to preserve the registers on the stack prior to turning control over to the requested service. However, this programming model will result in somewhat slower execution as compared to calling a service as a subroutine, primarily a result of the stack activity that occurs with any interrupt. Also, interrupt requests will have been disabled by executing Шаблон:Mono or Шаблон:Mono, requiring that the operating system re-enable them.

Шаблон:Mono and Шаблон:Mono instructions

Шаблон:Mono (WAit for Interrupt, opcode Шаблон:Mono) is an instruction available on the WDC version of the 65C02 and the 65C816/65C802 microprocessors (MPU) that halts the MPU and places it into a semi-catatonic state until a hardware interrupt of any kind occurs.^[2] The primary use for Шаблон:Mono is in low-power embedded systems where the MPU has nothing to do until an expected event occurs and minimal power consumption is desired as the system is waiting, and/or a quick response is required. A typical example of code that would make use of Шаблон:Mono is as follows:

        SEI                     ; disable IRQs
        WAI                     ; wait for hardware interrupt
        ; ... execution resumes here

In the above code fragment, the MPU will halt upon execution of Шаблон:Mono and go into a very low power consumption state. Despite interrupt requests (IRQ) having been disabled prior to the Шаблон:Mono instruction, the MPU will respond to any hardware interrupt while waiting. Upon receipt of an interrupt, the MPU will "awaken" in one clock cycle and resume execution at the instruction immediately following Шаблон:Mono. Hence interrupt latency will be very short (70 nanoseconds at 14 megahertz), resulting in the most rapid response possible to an external event.

Similar in some ways to Шаблон:Mono is the Шаблон:Mono (SToP, opcode Шаблон:Mono) instruction, which completely shuts down the MPU while waiting for a single interrupt input.^[2] When Шаблон:Mono is executed, the MPU halts its internal clock (but does retain all data in its registers) and enters a low power state. The MPU is brought out of this state by pulling its reset input pin (Шаблон:Mono, which is classified as an interrupt input) low. Execution will then resume at the address stored at locations Шаблон:Mono, the hardware reset vector. As with Шаблон:Mono, Шаблон:Mono is intended for use in low power embedded applications where long periods of time may elapse between events that require MPU attention and no other processing is required. Шаблон:Mono would not be used in normal programming, as it would result in total cessation of processing.

Footnotes

↑ Ошибка цитирования Неверный тег <ref>; для сносок ABORT не указан текст
↑ Ошибка цитирования Неверный тег <ref>; для сносок COP не указан текст

References

↑ ^1,0 ^1,1 ^1,2 ^1,3 ^1,4 Шаблон:Cite book
↑ ^2,00 ^2,01 ^2,02 ^2,03 ^2,04 ^2,05 ^2,06 ^2,07 ^2,08 ^2,09 ^2,10 ^2,11 ^2,12 ^2,13 ^2,14 ^2,15 ^2,16 ^2,17 ^2,18 ^2,19 ^2,20 ^2,21 ^2,22 Шаблон:Cite web
↑ ^3,0 ^3,1 Шаблон:Cite web
↑ ^4,0 ^4,1 Шаблон:Cite book
↑ ^5,0 ^5,1 ^5,2 Шаблон:Cite book
↑ Шаблон:Cite book
↑ Шаблон:Cite book
↑ Шаблон:Cite magazine
↑ Шаблон:Cite book

Партнерские ресурсы
Криптовалюты	Обмен криптовалют - www.bestchange.ru Криптовалютная биржа CoinEx Криптовалютная биржа Binance HIVE OS - операционная система для майнинга e4pool - Мультивалютный пул для майнинга.
Магазины	AliExpress — глобальная виртуальная (в Интернете) торговая площадка, предоставляющая возможность покупать товары производителей из КНР; computeruniverse.net - Интернет-магазин компьютеров(Промо код 5 Евро на первую покупку:FWWC3ZKQ);
Хостинг	DigitalOcean - американский провайдер облачных инфраструктур, с главным офисом в Нью-Йорке и с центрами обработки данных по всему миру;
Разное	Викиум - Онлайн-тренажер для мозга Like Центр - Центр поддержки и развития предпринимательства. Gamersbay - лучший магазин по бустингу для World of Warcraft. Ноотропы OmniMind N°1 - Усиливает мозговую активность. Повышает мотивацию. Улучшает память. Санкт-Петербургская школа телевидения - это федеральная сеть образовательных центров, которая имеет филиалы в 37 городах России. Lingualeo.com — интерактивный онлайн-сервис для изучения и практики английского языка в увлекательной игровой форме. Junyschool (Джунискул) – международная школа программирования и дизайна для детей и подростков от 5 до 17 лет, где ученики осваивают компьютерную грамотность, развивают алгоритмическое и креативное мышление, изучают основы программирования и компьютерной графики, создают собственные проекты: игры, сайты, программы, приложения, анимации, 3D-модели, монтируют видео. Умназия - Интерактивные онлайн-курсы и тренажеры для развития мышления детей 6-13 лет SkillBox - это один из лидеров российского рынка онлайн-образования. Среди партнеров Skillbox ведущий разработчик сервисного дизайна AIC, медиа-компания Yoola, первое и самое крупное русскоязычное аналитическое агентство Tagline, онлайн-школа дизайна и иллюстрации Bang! Bang! Education, оператор PR-рынка PACO, студия рисования Draw&Go, агентство performance-маркетинга Ingate, scrum-студия Sibirix, имидж-лаборатория Персона. «Нетология» — это университет по подготовке и дополнительному обучению специалистов в области интернет-маркетинга, управления проектами и продуктами, дизайна, Data Science и разработки. В рамках Нетологии студенты получают ценные теоретические знания от лучших экспертов Рунета, выполняют практические задания на отработку полученных навыков, общаются с экспертами и единомышленниками. Познакомиться со всеми продуктами подробнее можно на сайте https://netology.ru, линейка курсов и профессий постоянно обновляется. StudyBay Brazil – это онлайн биржа для португалоговорящих студентов и авторов! Студент получает уникальную работу любого уровня сложности и больше свободного времени, в то время как у автора появляется дополнительный заработок и бесценный опыт. Автор24 — самая большая в России площадка по написанию учебных работ: контрольные и курсовые работы, дипломы, рефераты, решение задач, отчеты по практике, а так же любой другой вид работы. Сервис сотрудничает с более 70 000 авторов. Более 1 000 000 работ уже выполнено. StudyBay – это онлайн биржа для англоязычных студентов и авторов! Студент получает уникальную работу любого уровня сложности и больше свободного времени, в то время как у автора появляется дополнительный заработок и бесценный опыт.

Английская Википедия:Interrupts in 65xx processors

Содержание

Interrupt types

Шаблон:Mono interrupt

Interrupt anomalies

Interrupt handler considerations

Using Шаблон:Mono and Шаблон:Mono

Шаблон:Mono and Шаблон:Mono instructions

Footnotes

References

Further reading

Навигация

Действия на странице

Действия на странице

Персональные инструменты

Навигация

Поиск

Инструменты