Subversion Repositories openrisc

#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 <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