drv_api.h

eCos操作系统源码

#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 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-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 <cyg/kernel/kapi.h>
//
//####DESCRIPTIONEND####
//
//========================================================================*/

#include <pkgconf/hal.h>
#include <cyg/infra/cyg_type.h>

#ifdef CYGPKG_KERNEL

/*------------------------------------------------------------------------*/
/* Kernel co-resident version of API                                      */

#include <pkgconf/kernel.h>

#ifndef CYGFUN_KERNEL_API_C
#error Driver API requres Kernel API to be present
#endif

#include <cyg/kernel/kapi.h>

#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