/**************************************************************************** * arch/x86/include/i486/irq.h * * Copyright (C) 2011 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 3. Neither the name NuttX nor the names of its contributors may be * used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ /* This file should never be included directed but, rather, only indirectly * through nuttx/irq.h */ #ifndef __ARCH_X86_INCLUDE_I486_IRQ_H #define __ARCH_X86_INCLUDE_I486_IRQ_H /**************************************************************************** * Included Files ****************************************************************************/ #ifndef __ASSEMBLY__ # include # include # include #endif /**************************************************************************** * Definitions ****************************************************************************/ /* ISR and IRQ numbers */ #define ISR0 0 #define ISR1 1 #define ISR2 2 #define ISR3 3 #define ISR4 4 #define ISR5 5 #define ISR6 6 #define ISR7 7 #define ISR8 8 #define ISR9 9 #define ISR10 10 #define ISR11 11 #define ISR12 12 #define ISR13 13 #define ISR14 14 #define ISR15 15 #define ISR16 16 #define ISR17 17 #define ISR18 18 #define ISR19 19 #define ISR20 20 #define ISR21 21 #define ISR22 22 #define ISR23 23 #define ISR24 24 #define ISR25 25 #define ISR26 26 #define ISR27 27 #define ISR28 28 #define ISR29 29 #define ISR30 30 #define ISR31 31 #define IRQ0 32 #define IRQ1 33 #define IRQ2 34 #define IRQ3 35 #define IRQ4 36 #define IRQ5 37 #define IRQ6 38 #define IRQ7 39 #define IRQ8 40 #define IRQ9 41 #define IRQ10 42 #define IRQ11 43 #define IRQ12 44 #define IRQ13 45 #define IRQ14 46 #define IRQ15 47 #define NR_IRQS 48 /* Common register save structgure created by up_saveusercontext() and by * ISR/IRQ interrupt processing. */ #define REG_DS (0) /* Data segment selector */ #define REG_EDI (1) /* Saved by pusha */ #define REG_ESI (2) /* " " "" " " */ #define REG_EBP (3) /* " " "" " " */ #define REG_ESP (4) /* " " "" " " (NOTE 1)*/ #define REG_EBX (5) /* " " "" " " */ #define REG_EDX (6) /* " " "" " " */ #define REG_ECX (7) /* " " "" " " */ #define REG_EAX (8) /* " " "" " " */ #define REG_IRQNO (9) /* Interrupt number (NOTE 2) */ #define REG_ERRCODE (10) /* Error code (NOTE 2) */ #define REG_EIP (11) /* Pushed by process on interrupt processing */ #define REG_CS (12) /* " " "" " " "" " " " " */ #define REG_EFLAGS (13) /* " " "" " " "" " " " " */ #define REG_SP (14) /* " " "" " " "" " " " " */ #define REG_SS (15) /* " " "" " " "" " " " " */ /* NOTE 1: Two versions of the ESP are saved: One from the interrupt * processing and one from pusha. Only the interrupt ESP (REG_SP) is used. * NOTE 2: This is not really state data. Rather, this is just a convenient * way to pass parameters from the interrupt handler to C cod. */ #define XCPTCONTEXT_REGS (16) #define XCPTCONTEXT_SIZE (4 * XCPTCONTEXT_REGS) /**************************************************************************** * Public Types ****************************************************************************/ /* This struct defines the way the registers are stored */ #ifndef __ASSEMBLY__ struct xcptcontext { /* The following function pointer is non-zero if there are pending signals * to be processed. */ #ifndef CONFIG_DISABLE_SIGNALS void *sigdeliver; /* Actual type is sig_deliver_t */ /* These are saved copies of instruction pointer and EFLAGS used during * signal processing. */ uint32_t saved_eip; uint32_t saved_eflags; #endif /* Register save area */ uint32_t regs[XCPTCONTEXT_REGS]; }; #endif /**************************************************************************** * Inline functions ****************************************************************************/ #ifndef __ASSEMBLY__ /* Get the current FLAGS register contents */ static inline irqstate_t irqflags() { irqstate_t flags; asm volatile( "\tpushf\n" "\tpop %0\n" : "=rm" (flags) : : "memory"); return flags; } /* Get a sample of the FLAGS register, determine if interrupts are disabled. * If the X86_FLAGS_IF is cleared by cli, then interrupts are disabled. If * if the X86_FLAGS_IF is set by sti, then interrupts are enable. */ static inline bool irqdisabled(irqstate_t flags) { return ((flags & X86_FLAGS_IF) == 0); } static inline bool irqenabled(irqstate_t flags) { return ((flags & X86_FLAGS_IF) != 0); } /* Disable interrupts unconditionally */ static inline void irqdisable(void) { asm volatile("cli": : :"memory"); } /* Enable interrupts unconditionally */ static inline void irqenable(void) { asm volatile("sti": : :"memory"); } /* Disable interrupts, but return previous interrupt state */ static inline irqstate_t irqsave(void) { irqstate_t flags = irqflags(); irqdisable(); return flags; } /* Conditionally disable interrupts */ static inline void irqrestore(irqstate_t flags) { if (irqenabled(flags)) { irqenable(); } } /**************************************************************************** * Public Variables ****************************************************************************/ /**************************************************************************** * Public Function Prototypes ****************************************************************************/ #ifdef __cplusplus #define EXTERN extern "C" extern "C" { #else #define EXTERN extern #endif #undef EXTERN #ifdef __cplusplus } #endif #endif /* __ASSEMBLY__ */ #endif /* __ARCH_X86_INCLUDE_I486_IRQ_H */