#ifndef CYGONCE_HAL_DRV_API_H #define CYGONCE_HAL_DRV_API_H /*========================================================================== // // drv_api.h // // Native API for Kernel // //========================================================================== // ####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. // // eCos is free software; you can redistribute it and/or modify it under // the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 or (at your option) any later // version. // // eCos is distributed in the hope that it will be useful, but WITHOUT // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License // along with eCos; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // As a special exception, if other files instantiate templates or use // macros or inline functions from this file, or you compile this file // and link it with other works to produce a work based on this file, // this file does not by itself cause the resulting work to be covered by // the GNU General Public License. However the source code for this file // must still be made available in accordance with section (3) of the GNU // General Public License v2. // // This exception does not invalidate any other reasons why a work based // on this file might be covered by the GNU General Public License. // ------------------------------------------- // ####ECOSGPLCOPYRIGHTEND#### //========================================================================== //#####DESCRIPTIONBEGIN#### // // Author(s): nickg // Date: 1999-02-24 // Purpose: Driver API // Description: This file defines the API used by device drivers to access // system services. When the kernel is present it maps directly // to the Kernel C API. When the kernel is absent, it is provided // by a set of HAL functions. // // Usage: #include // //####DESCRIPTIONEND#### // //========================================================================*/ //#include //mod by prife #include #ifdef CYGPKG_KERNEL /*------------------------------------------------------------------------*/ /* Kernel co-resident version of API */ #include #ifndef CYGFUN_KERNEL_API_C #error Driver API requres Kernel API to be present #endif #include #define cyg_drv_isr_lock cyg_interrupt_disable #define cyg_drv_isr_unlock cyg_interrupt_enable #define cyg_drv_dsr_lock cyg_scheduler_lock #define cyg_drv_dsr_unlock cyg_scheduler_unlock #define cyg_drv_mutex_t cyg_mutex_t #define cyg_drv_mutex_init cyg_mutex_init #define cyg_drv_mutex_destroy cyg_mutex_destroy #define cyg_drv_mutex_lock cyg_mutex_lock #define cyg_drv_mutex_trylock cyg_mutex_trylock #define cyg_drv_mutex_unlock cyg_mutex_unlock #define cyg_drv_mutex_release cyg_mutex_release #define cyg_drv_cond_t cyg_cond_t #define cyg_drv_cond_init cyg_cond_init #define cyg_drv_cond_destroy cyg_cond_destroy #define cyg_drv_cond_wait cyg_cond_wait #define cyg_drv_cond_signal cyg_cond_signal #define cyg_drv_cond_broadcast cyg_cond_broadcast #define cyg_drv_interrupt_create cyg_interrupt_create #define cyg_drv_interrupt_delete cyg_interrupt_delete #define cyg_drv_interrupt_attach cyg_interrupt_attach #define cyg_drv_interrupt_detach cyg_interrupt_detach #define cyg_drv_interrupt_mask cyg_interrupt_mask #define cyg_drv_interrupt_unmask cyg_interrupt_unmask #define cyg_drv_interrupt_mask_intunsafe cyg_interrupt_mask_intunsafe #define cyg_drv_interrupt_unmask_intunsafe cyg_interrupt_unmask_intunsafe #define cyg_drv_interrupt_acknowledge cyg_interrupt_acknowledge #define cyg_drv_interrupt_configure cyg_interrupt_configure #define cyg_drv_interrupt_level cyg_interrupt_level #define cyg_drv_interrupt_set_cpu cyg_interrupt_set_cpu #define cyg_drv_interrupt_get_cpu cyg_interrupt_get_cpu #define cyg_drv_spinlock_t cyg_spinlock_t #define cyg_drv_spinlock_init cyg_spinlock_init #define cyg_drv_spinlock_spin cyg_spinlock_spin #define cyg_drv_spinlock_clear cyg_spinlock_clear #define cyg_drv_spinlock_try cyg_spinlock_try #define cyg_drv_spinlock_test cyg_spinlock_test #define cyg_drv_spinlock_spin_intsave cyg_spinlock_spin_intsave #define cyg_drv_spinlock_clear_intsave cyg_spinlock_clear_intsave #else /* CYGPKG_KERNEL */ /*------------------------------------------------------------------------*/ /* Non-kernel version of API */ typedef CYG_ADDRWORD cyg_addrword_t; /* May hold pointer or word */ typedef cyg_addrword_t cyg_handle_t; /* Object handle */ typedef cyg_uint32 cyg_priority_t; /* type for priorities */ typedef cyg_uint32 cyg_vector_t; /* Interrupt vector id */ typedef cyg_uint32 cyg_cpu_t; /* CPU id */ typedef int cyg_bool_t; typedef cyg_int32 cyg_code_t; /* type for various codes */ typedef cyg_uint32 cyg_ISR_t( cyg_vector_t vector, cyg_addrword_t data); typedef void cyg_DSR_t(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data); externC void cyg_drv_isr_lock(void); externC void cyg_drv_isr_unlock(void); externC void cyg_drv_dsr_lock(void); externC void cyg_drv_dsr_unlock(void); typedef struct { cyg_atomic lock; } cyg_drv_mutex_t; externC void cyg_drv_mutex_init( cyg_drv_mutex_t *mutex ); externC void cyg_drv_mutex_destroy( cyg_drv_mutex_t *mutex ); externC cyg_bool_t cyg_drv_mutex_lock( cyg_drv_mutex_t *mutex ); externC cyg_bool_t cyg_drv_mutex_trylock( cyg_drv_mutex_t *mutex ); externC void cyg_drv_mutex_unlock( cyg_drv_mutex_t *mutex ); externC void cyg_drv_mutex_release( cyg_drv_mutex_t *mutex ); typedef struct { cyg_atomic wait; cyg_drv_mutex_t *mutex; } cyg_drv_cond_t; externC void cyg_drv_cond_init( cyg_drv_cond_t *cond, cyg_drv_mutex_t *mutex ); externC void cyg_drv_cond_destroy( cyg_drv_cond_t *cond ); externC cyg_bool_t cyg_drv_cond_wait( cyg_drv_cond_t *cond ); externC void cyg_drv_cond_signal( cyg_drv_cond_t *cond ); externC void cyg_drv_cond_broadcast( cyg_drv_cond_t *cond ); typedef struct cyg_interrupt { cyg_vector_t vector; cyg_priority_t priority; cyg_ISR_t *isr; cyg_DSR_t *dsr; CYG_ADDRWORD data; struct cyg_interrupt* volatile next_dsr; volatile cyg_int32 dsr_count; #ifdef CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN struct cyg_interrupt *next; #endif } cyg_interrupt; externC void cyg_drv_interrupt_create( cyg_vector_t vector, cyg_priority_t priority, cyg_addrword_t data, cyg_ISR_t *isr, cyg_DSR_t *dsr, cyg_handle_t *handle, cyg_interrupt *intr ); externC void cyg_drv_interrupt_delete( cyg_handle_t interrupt ); externC void cyg_drv_interrupt_attach( cyg_handle_t interrupt ); externC void cyg_drv_interrupt_detach( cyg_handle_t interrupt ); externC void cyg_drv_interrupt_mask( cyg_vector_t vector ); externC void cyg_drv_interrupt_mask_intunsafe( cyg_vector_t vector ); externC void cyg_drv_interrupt_unmask( cyg_vector_t vector ); externC void cyg_drv_interrupt_unmask_intunsafe( cyg_vector_t vector ); externC void cyg_drv_interrupt_acknowledge( cyg_vector_t vector ); externC void cyg_drv_interrupt_configure( cyg_vector_t vector, cyg_bool_t level, cyg_bool_t up ); externC void cyg_drv_interrupt_level( cyg_vector_t vector, cyg_priority_t level ); externC void cyg_drv_interrupt_set_cpu( cyg_vector_t vector, cyg_cpu_t cpu ); externC cyg_cpu_t cyg_drv_interrupt_get_cpu( cyg_vector_t vector ); enum cyg_ISR_results { CYG_ISR_HANDLED = 1, /* Interrupt was handled */ CYG_ISR_CALL_DSR = 2 /* Schedule DSR */ }; typedef struct { cyg_atomic lock; } cyg_drv_spinlock_t; void cyg_drv_spinlock_init( cyg_drv_spinlock_t *lock, /* spinlock to initialize */ cyg_bool_t locked /* init locked or unlocked */ ); void cyg_drv_spinlock_destroy( cyg_drv_spinlock_t *lock ); void cyg_drv_spinlock_spin( cyg_drv_spinlock_t *lock ); void cyg_drv_spinlock_clear( cyg_drv_spinlock_t *lock ); cyg_bool_t cyg_drv_spinlock_try( cyg_drv_spinlock_t *lock ); cyg_bool_t cyg_drv_spinlock_test( cyg_drv_spinlock_t *lock ); void cyg_drv_spinlock_spin_intsave( cyg_drv_spinlock_t *lock, cyg_addrword_t *istate ); void cyg_drv_spinlock_clear_intsave( cyg_drv_spinlock_t *lock, cyg_addrword_t istate ); #endif /* CYGPKG_KERNEL */ /*------------------------------------------------------------------------*/ /* EOF drv_api.h */ #endif // CYGONCE_HAL_DRV_API_H