mirror of
https://github.com/PX4/PX4-Autopilot.git
synced 2026-06-07 17:35:22 +08:00
Merge branch 'master' into nuttx-merge-5447
This commit is contained in:
px4dev
@@ -40,6 +40,9 @@
|
||||
// Included Files
|
||||
//***************************************************************************
|
||||
|
||||
#include <nuttx/config.h>
|
||||
#include <nuttx/compiler.h>
|
||||
|
||||
#include <math.h>
|
||||
|
||||
//***************************************************************************
|
||||
@@ -48,6 +51,34 @@
|
||||
|
||||
namespace std
|
||||
{
|
||||
#if CONFIG_HAVE_FLOAT
|
||||
using ::acosf;
|
||||
using ::asinf;
|
||||
using ::atanf;
|
||||
using ::atan2f;
|
||||
using ::ceilf;
|
||||
using ::cosf;
|
||||
using ::coshf;
|
||||
using ::expf;
|
||||
using ::fabsf;
|
||||
using ::floorf;
|
||||
using ::fmodf;
|
||||
using ::frexpf;
|
||||
using ::ldexpf;
|
||||
using ::logf;
|
||||
using ::log10f;
|
||||
using ::log2f;
|
||||
using ::modff;
|
||||
using ::roundf;
|
||||
using ::powf;
|
||||
using ::sinf;
|
||||
using ::sinhf;
|
||||
using ::sqrtf;
|
||||
using ::tanf;
|
||||
using ::tanhf;
|
||||
#endif
|
||||
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
using ::acos;
|
||||
using ::asin;
|
||||
using ::atan;
|
||||
@@ -63,13 +94,44 @@ namespace std
|
||||
using ::ldexp;
|
||||
using ::log;
|
||||
using ::log10;
|
||||
using ::log2;
|
||||
using ::modf;
|
||||
using ::round;
|
||||
using ::pow;
|
||||
using ::sin;
|
||||
using ::sinh;
|
||||
using ::sqrt;
|
||||
using ::tan;
|
||||
using ::tanh;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
using ::acosl;
|
||||
using ::asinl;
|
||||
using ::atanl;
|
||||
using ::atan2l;
|
||||
using ::ceill;
|
||||
using ::cosl;
|
||||
using ::coshl;
|
||||
using ::expl;
|
||||
using ::fabsl;
|
||||
using ::floorl;
|
||||
using ::fmodl;
|
||||
using ::frexpl;
|
||||
using ::ldexpl;
|
||||
using ::logl;
|
||||
using ::log10l;
|
||||
using ::log2l;
|
||||
using ::modfl;
|
||||
using ::roundl;
|
||||
using ::powl;
|
||||
using ::sinl;
|
||||
using ::sinhl;
|
||||
using ::sqrtl;
|
||||
using ::tanl;
|
||||
using ::tanhl;
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif // __INCLUDE_CXX_CMATH
|
||||
|
||||
@@ -70,6 +70,7 @@ namespace std
|
||||
#endif
|
||||
|
||||
using ::strtol;
|
||||
using ::strtoul;
|
||||
using ::strtod;
|
||||
|
||||
using ::malloc;
|
||||
|
||||
+10
-15
@@ -571,12 +571,9 @@
|
||||
* Public Function Prototypes
|
||||
****************************************************************************/
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
#define EXTERN extern "C"
|
||||
extern "C" {
|
||||
#else
|
||||
#define EXTERN extern
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/* These low-level debug APIs are provided by the NuttX library. If the
|
||||
@@ -585,21 +582,20 @@ extern "C" {
|
||||
* or the other of the following.
|
||||
*/
|
||||
|
||||
EXTERN int lib_rawprintf(FAR const char *format, ...);
|
||||
int lib_rawprintf(FAR const char *format, ...);
|
||||
|
||||
#ifdef CONFIG_ARCH_LOWPUTC
|
||||
EXTERN int lib_lowprintf(FAR const char *format, ...);
|
||||
int lib_lowprintf(FAR const char *format, ...);
|
||||
#endif
|
||||
|
||||
/* Dump a buffer of data */
|
||||
|
||||
EXTERN void lib_dumpbuffer(FAR const char *msg, FAR const uint8_t *buffer,
|
||||
unsigned int buflen);
|
||||
void lib_dumpbuffer(FAR const char *msg, FAR const uint8_t *buffer, unsigned int buflen);
|
||||
|
||||
/* Enable or disable debug output */
|
||||
|
||||
#ifdef CONFIG_DEBUG_ENABLE
|
||||
EXTERN void dbg_enable(bool enable);
|
||||
void dbg_enable(bool enable);
|
||||
#endif
|
||||
|
||||
/* If the cross-compiler's pre-processor does not support variable length
|
||||
@@ -608,23 +604,22 @@ EXTERN void dbg_enable(bool enable);
|
||||
|
||||
#ifndef CONFIG_CPP_HAVE_VARARGS
|
||||
#ifdef CONFIG_DEBUG
|
||||
EXTERN int dbg(const char *format, ...);
|
||||
int dbg(const char *format, ...);
|
||||
|
||||
# ifdef CONFIG_ARCH_LOWPUTC
|
||||
EXTERN int lldbg(const char *format, ...);
|
||||
int lldbg(const char *format, ...);
|
||||
# endif
|
||||
|
||||
# ifdef CONFIG_DEBUG_VERBOSE
|
||||
EXTERN int vdbg(const char *format, ...);
|
||||
int vdbg(const char *format, ...);
|
||||
|
||||
# ifdef CONFIG_ARCH_LOWPUTC
|
||||
EXTERN int llvdbg(const char *format, ...);
|
||||
int llvdbg(const char *format, ...);
|
||||
# endif
|
||||
#endif
|
||||
#endif /* CONFIG_DEBUG */
|
||||
#endif /* CONFIG_CPP_HAVE_VARARGS */
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
+259
-31
@@ -46,6 +46,7 @@
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <sched.h>
|
||||
|
||||
#include <arch/arch.h>
|
||||
|
||||
/****************************************************************************
|
||||
@@ -67,10 +68,8 @@ typedef CODE void (*sig_deliver_t)(FAR _TCB *tcb);
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define EXTERN extern "C"
|
||||
extern "C" {
|
||||
#else
|
||||
#define EXTERN extern
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -98,7 +97,7 @@ extern "C" {
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_initialize(void);
|
||||
void up_initialize(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_idle
|
||||
@@ -114,7 +113,7 @@ EXTERN void up_initialize(void);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_idle(void);
|
||||
void up_idle(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_initial_state
|
||||
@@ -130,7 +129,7 @@ EXTERN void up_idle(void);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_initial_state(FAR _TCB *tcb);
|
||||
void up_initial_state(FAR _TCB *tcb);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_create_stack
|
||||
@@ -155,7 +154,7 @@ EXTERN void up_initial_state(FAR _TCB *tcb);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_CUSTOM_STACK
|
||||
EXTERN int up_create_stack(FAR _TCB *tcb, size_t stack_size);
|
||||
int up_create_stack(FAR _TCB *tcb, size_t stack_size);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -180,7 +179,7 @@ EXTERN int up_create_stack(FAR _TCB *tcb, size_t stack_size);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_CUSTOM_STACK
|
||||
EXTERN int up_use_stack(FAR _TCB *tcb, FAR void *stack, size_t stack_size);
|
||||
int up_use_stack(FAR _TCB *tcb, FAR void *stack, size_t stack_size);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -193,7 +192,7 @@ EXTERN int up_use_stack(FAR _TCB *tcb, FAR void *stack, size_t stack_size);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_CUSTOM_STACK
|
||||
EXTERN void up_release_stack(FAR _TCB *dtcb);
|
||||
void up_release_stack(FAR _TCB *dtcb);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -216,7 +215,7 @@ EXTERN void up_release_stack(FAR _TCB *dtcb);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_unblock_task(FAR _TCB *tcb);
|
||||
void up_unblock_task(FAR _TCB *tcb);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_block_task
|
||||
@@ -242,7 +241,7 @@ EXTERN void up_unblock_task(FAR _TCB *tcb);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_block_task(FAR _TCB *tcb, tstate_t task_state);
|
||||
void up_block_task(FAR _TCB *tcb, tstate_t task_state);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_release_pending
|
||||
@@ -261,7 +260,7 @@ EXTERN void up_block_task(FAR _TCB *tcb, tstate_t task_state);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_release_pending(void);
|
||||
void up_release_pending(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_reprioritize_rtr
|
||||
@@ -287,7 +286,7 @@ EXTERN void up_release_pending(void);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority);
|
||||
void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: _exit
|
||||
@@ -349,7 +348,7 @@ EXTERN void up_reprioritize_rtr(FAR _TCB *tcb, uint8_t priority);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_DISABLE_SIGNALS
|
||||
EXTERN void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver);
|
||||
void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -363,7 +362,7 @@ EXTERN void up_schedule_sigaction(FAR _TCB *tcb, sig_deliver_t sigdeliver);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_HEAP_BASE
|
||||
EXTERN void up_allocate_heap(FAR void **heap_start, size_t *heap_size);
|
||||
void up_allocate_heap(FAR void **heap_start, size_t *heap_size);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -382,6 +381,214 @@ EXTERN void up_allocate_heap(FAR void **heap_start, size_t *heap_size);
|
||||
# define up_getpicbase(ppicbase)
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Address Environment Interfaces
|
||||
*
|
||||
* Low-level interfaces used in binfmt/ to instantiate tasks with address
|
||||
* environments. These interfaces all operate on type task_addrenv_t which
|
||||
* is an abstract representation of a task's address environment and must be
|
||||
* defined in arch/arch.h if CONFIG_ADDRENV is defined.
|
||||
*
|
||||
* up_addrenv_create - Create an address environment
|
||||
* up_addrenv_vaddr - Returns the virtual base address of the address
|
||||
* environment
|
||||
* up_addrenv_select - Instantiate an address environment
|
||||
* up_addrenv_restore - Restore an address environment
|
||||
* up_addrenv_destroy - Destroy an address environment.
|
||||
* up_addrenv_assign - Assign an address environment to a TCB
|
||||
*
|
||||
* Higher-level interfaces used by the tasking logic. These interfaces are
|
||||
* used by the functions in sched/ and all operate on the TCB which as been
|
||||
* assigned an address environment by up_addrenv_assign().
|
||||
*
|
||||
* up_addrenv_share - Clone the address environment assigned to one TCB
|
||||
* to another. This operation is done when a pthread
|
||||
* is created that share's the same address
|
||||
* environment.
|
||||
* up_addrenv_release - Release the TCBs reference to an address
|
||||
* environment when a task/thread exits.
|
||||
*
|
||||
****************************************************************************/
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_create
|
||||
*
|
||||
* Description:
|
||||
* This function is called from the binary loader logic when a new
|
||||
* task is created in order to instantiate an address environment for the
|
||||
* task. up_addrenv_create is essentially the allocator of the physical
|
||||
* memory for the new task.
|
||||
*
|
||||
* Input Parameters:
|
||||
* envsize - The size (in bytes) of the address environment needed by the
|
||||
* task.
|
||||
* addrenv - The location to return the representation of the task address
|
||||
* environment.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_create(size_t envsize, FAR task_addrenv_t *addrenv);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_vaddr
|
||||
*
|
||||
* Description:
|
||||
* Return the virtual address associated with the newly create address
|
||||
* environment. This function is used by the binary loaders in order
|
||||
* get an address that can be used to initialize the new task.
|
||||
*
|
||||
* Input Parameters:
|
||||
* addrenv - The representation of the task address environment previously
|
||||
* returned by up_addrenv_create.
|
||||
* vaddr - The location to return the virtual address.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_vaddr(FAR task_addrenv_t addrenv, FAR void **vaddr);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_select
|
||||
*
|
||||
* Description:
|
||||
* After an address environment has been established for a task (via
|
||||
* up_addrenv_create(). This function may be called to to instantiate
|
||||
* that address environment in the virtual address space. this might be
|
||||
* necessary, for example, to load the code for the task from a file or
|
||||
* to access address environment private data.
|
||||
*
|
||||
* Input Parameters:
|
||||
* addrenv - The representation of the task address environment previously
|
||||
* returned by up_addrenv_create.
|
||||
* oldenv
|
||||
* The address environment that was in place before up_addrenv_select().
|
||||
* This may be used with up_addrenv_restore() to restore the original
|
||||
* address environment that was in place before up_addrenv_select() was
|
||||
* called. Note that this may be a task agnostic, hardware
|
||||
* representation that is different from task_addrenv_t.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_select(task_addrenv_t addrenv, hw_addrenv_t *oldenv);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_restore
|
||||
*
|
||||
* Description:
|
||||
* After an address environment has been temporarilty instantiated by
|
||||
* up_addrenv_select, this function may be called to to restore the
|
||||
* original address environment.
|
||||
*
|
||||
* Input Parameters:
|
||||
* oldenv - The hardware representation of the address environment
|
||||
* previously returned by up_addrenv_select.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_restore(hw_addrenv_t oldenv);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_destroy
|
||||
*
|
||||
* Description:
|
||||
* Called from the binary loader loader during error handling to destroy
|
||||
* the address environment previously created by up_addrenv_create().
|
||||
*
|
||||
* Input Parameters:
|
||||
* addrenv - The representation of the task address environment previously
|
||||
* returned by up_addrenv_create.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_destroy(task_addrenv_t addrenv);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_assign
|
||||
*
|
||||
* Description:
|
||||
* Assign an address environment to a TCB.
|
||||
*
|
||||
* Input Parameters:
|
||||
* addrenv - The representation of the task address environment previously
|
||||
* returned by up_addrenv_create.
|
||||
* tcb - The TCB of the task to receive the address environment.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_assign(task_addrenv_t addrenv, FAR _TCB *tcb);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_share
|
||||
*
|
||||
* Description:
|
||||
* This function is called from the core scheduler logic when a thread
|
||||
* is created that needs to share the address ennvironment of its parent
|
||||
* task. In this case, the parent's address environment needs to be
|
||||
* "cloned" for the child.
|
||||
*
|
||||
* Input Parameters:
|
||||
* ptcb - The TCB of the parent task that has the address environment.
|
||||
* ctcb - The TCB of the child thread needing the address environment.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_share(FAR const _TCB *ptcb, FAR _TCB *ctcb);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_addrenv_release
|
||||
*
|
||||
* Description:
|
||||
* This function is called when a task or thread exits in order to release
|
||||
* its reference to an address environment. When there are no further
|
||||
* references to an address environment, that address environment should
|
||||
* be destroyed.
|
||||
*
|
||||
* Input Parameters:
|
||||
* tcb - The TCB of the task or thread whose the address environment will
|
||||
* be released.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) on success; a negated errno value on failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
int up_addrenv_release(FAR _TCB *tcb);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_interrupt_context
|
||||
*
|
||||
@@ -391,7 +598,7 @@ EXTERN void up_allocate_heap(FAR void **heap_start, size_t *heap_size);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN bool up_interrupt_context(void);
|
||||
bool up_interrupt_context(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_enable_irq
|
||||
@@ -413,7 +620,7 @@ EXTERN bool up_interrupt_context(void);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_ARCH_NOINTC
|
||||
EXTERN void up_enable_irq(int irq);
|
||||
void up_enable_irq(int irq);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -431,7 +638,7 @@ EXTERN void up_enable_irq(int irq);
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef CONFIG_ARCH_NOINTC
|
||||
EXTERN void up_disable_irq(int irq);
|
||||
void up_disable_irq(int irq);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -446,7 +653,7 @@ EXTERN void up_disable_irq(int irq);
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ARCH_IRQPRIO
|
||||
EXTERN int up_prioritize_irq(int irq, int priority);
|
||||
int up_prioritize_irq(int irq, int priority);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -483,7 +690,7 @@ EXTERN int up_prioritize_irq(int irq, int priority);
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ARCH_ROMGETC
|
||||
EXTERN char up_romgetc(FAR const char *ptr);
|
||||
char up_romgetc(FAR const char *ptr);
|
||||
#else
|
||||
# define up_romgetc(ptr) (*ptr)
|
||||
#endif
|
||||
@@ -497,8 +704,8 @@ EXTERN char up_romgetc(FAR const char *ptr);
|
||||
*
|
||||
***************************************************************************/
|
||||
|
||||
EXTERN void up_mdelay(unsigned int milliseconds);
|
||||
EXTERN void up_udelay(useconds_t microseconds);
|
||||
void up_mdelay(unsigned int milliseconds);
|
||||
void up_udelay(useconds_t microseconds);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: up_cxxinitialize
|
||||
@@ -517,7 +724,7 @@ EXTERN void up_udelay(useconds_t microseconds);
|
||||
***************************************************************************/
|
||||
|
||||
#if defined(CONFIG_HAVE_CXX) && defined(CONFIG_HAVE_CXXINITIALIZE)
|
||||
EXTERN void up_cxxinitialize(void);
|
||||
void up_cxxinitialize(void);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -537,7 +744,7 @@ EXTERN void up_cxxinitialize(void);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void sched_process_timer(void);
|
||||
void sched_process_timer(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: irq_dispatch
|
||||
@@ -549,7 +756,7 @@ EXTERN void sched_process_timer(void);
|
||||
*
|
||||
***************************************************************************/
|
||||
|
||||
EXTERN void irq_dispatch(int irq, FAR void *context);
|
||||
void irq_dispatch(int irq, FAR void *context);
|
||||
|
||||
/****************************************************************************
|
||||
* Board-specific button interfaces exported by the board-specific logic
|
||||
@@ -571,7 +778,7 @@ EXTERN void irq_dispatch(int irq, FAR void *context);
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ARCH_BUTTONS
|
||||
EXTERN void up_buttoninit(void);
|
||||
void up_buttoninit(void);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -592,7 +799,7 @@ EXTERN void up_buttoninit(void);
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ARCH_BUTTONS
|
||||
EXTERN uint8_t up_buttons(void);
|
||||
uint8_t up_buttons(void);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -613,7 +820,29 @@ EXTERN uint8_t up_buttons(void);
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ARCH_IRQBUTTONS
|
||||
EXTERN xcpt_t up_irqbutton(int id, xcpt_t irqhandler);
|
||||
xcpt_t up_irqbutton(int id, xcpt_t irqhandler);
|
||||
#endif
|
||||
|
||||
/************************************************************************************
|
||||
* Relay control functions
|
||||
*
|
||||
* Description:
|
||||
* Non-standard functions for relay control.
|
||||
*
|
||||
************************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ARCH_RELAYS
|
||||
void up_relaysinit(void);
|
||||
void relays_setstat(int relays, bool stat);
|
||||
bool relays_getstat(int relays);
|
||||
void relays_setstats(uint32_t relays_stat);
|
||||
uint32_t relays_getstats(void);
|
||||
void relays_onoff(int relays, uint32_t mdelay);
|
||||
void relays_onoffs(uint32_t relays_stat, uint32_t mdelay);
|
||||
void relays_resetmode(int relays);
|
||||
void relays_powermode(int relays);
|
||||
void relays_resetmodes(uint32_t relays_stat);
|
||||
void relays_powermodes(uint32_t relays_stat);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
@@ -628,9 +857,8 @@ EXTERN xcpt_t up_irqbutton(int id, xcpt_t irqhandler);
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int up_putc(int ch);
|
||||
int up_putc(int ch);
|
||||
|
||||
#undef EXTERN
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,338 @@
|
||||
/****************************************************************************
|
||||
* include/nuttx/binfmt/binfmt.h
|
||||
*
|
||||
* Copyright (C) 2009, 2012 Gregory Nutt. All rights reserved.
|
||||
* Author: Gregory Nutt <gnutt@nuttx.org>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __INCLUDE_NUTTX_BINFMT_BINFMT_H
|
||||
#define __INCLUDE_NUTTX_BINFMT_BINFMT_H
|
||||
|
||||
/****************************************************************************
|
||||
* Included Files
|
||||
****************************************************************************/
|
||||
|
||||
#include <nuttx/config.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <nxflat.h>
|
||||
|
||||
#include <nuttx/arch.h>
|
||||
#include <nuttx/sched.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Pre-processor Definitions
|
||||
****************************************************************************/
|
||||
|
||||
#define BINFMT_NALLOC 3
|
||||
|
||||
/****************************************************************************
|
||||
* Public Types
|
||||
****************************************************************************/
|
||||
/* EXEPATH_HANDLE is an opaque handle used to traverse the absolute paths
|
||||
* assigned to the PATH environment variable.
|
||||
*/
|
||||
|
||||
#if !defined(CONFIG_BINFMT_DISABLE) && defined(CONFIG_BINFMT_EXEPATH)
|
||||
typedef FAR void *EXEPATH_HANDLE;
|
||||
#endif
|
||||
|
||||
/* The type of one C++ constructor or destructor */
|
||||
|
||||
typedef FAR void (*binfmt_ctor_t)(void);
|
||||
typedef FAR void (*binfmt_dtor_t)(void);
|
||||
|
||||
/* This describes the file to be loaded.
|
||||
*
|
||||
* NOTE 1: The 'filename' must be the full, absolute path to the file to be
|
||||
* executed unless CONFIG_BINFMT_EXEPATH is defined. In that case,
|
||||
* 'filename' may be a relative path; a set of candidate absolute paths
|
||||
* will be generated using the PATH environment variable and load_module()
|
||||
* will attempt to load each file that is found at those absolute paths.
|
||||
*/
|
||||
|
||||
struct symtab_s;
|
||||
struct binary_s
|
||||
{
|
||||
/* Information provided to the loader to load and bind a module */
|
||||
|
||||
FAR const char *filename; /* Full path to the binary to be loaded (See NOTE 1 above) */
|
||||
FAR const char **argv; /* Argument list */
|
||||
FAR const struct symtab_s *exports; /* Table of exported symbols */
|
||||
int nexports; /* The number of symbols in exports[] */
|
||||
|
||||
/* Information provided from the loader (if successful) describing the
|
||||
* resources used by the loaded module.
|
||||
*/
|
||||
|
||||
main_t entrypt; /* Entry point into a program module */
|
||||
FAR void *mapped; /* Memory-mapped, address space */
|
||||
FAR void *alloc[BINFMT_NALLOC]; /* Allocated address spaces */
|
||||
|
||||
/* Constructors/destructors */
|
||||
|
||||
#ifdef CONFIG_BINFMT_CONSTRUCTORS
|
||||
FAR binfmt_ctor_t *ctors; /* Pointer to a list of constructors */
|
||||
FAR binfmt_dtor_t *dtors; /* Pointer to a list of destructors */
|
||||
uint16_t nctors; /* Number of constructors in the list */
|
||||
uint16_t ndtors; /* Number of destructors in the list */
|
||||
#endif
|
||||
|
||||
/* Address environment.
|
||||
*
|
||||
* addrenv - This is the handle created by up_addrenv_create() that can be
|
||||
* used to manage the tasks address space.
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
task_addrenv_t addrenv; /* Task address environment */
|
||||
#endif
|
||||
|
||||
size_t mapsize; /* Size of the mapped address region (needed for munmap) */
|
||||
size_t stacksize; /* Size of the stack in bytes (unallocated) */
|
||||
};
|
||||
|
||||
/* This describes one binary format handler */
|
||||
|
||||
struct binfmt_s
|
||||
{
|
||||
FAR struct binfmt_s *next; /* Supports a singly-linked list */
|
||||
int (*load)(FAR struct binary_s *bin); /* Verify and load binary into memory */
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
* Public Data
|
||||
****************************************************************************/
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Public Function Prototypes
|
||||
****************************************************************************/
|
||||
|
||||
/****************************************************************************
|
||||
* Name: register_binfmt
|
||||
*
|
||||
* Description:
|
||||
* Register a loader for a binary format
|
||||
*
|
||||
* Returned Value:
|
||||
* This is a NuttX internal function so it follows the convention that
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
int register_binfmt(FAR struct binfmt_s *binfmt);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: unregister_binfmt
|
||||
*
|
||||
* Description:
|
||||
* Register a loader for a binary format
|
||||
*
|
||||
* Returned Value:
|
||||
* This is a NuttX internal function so it follows the convention that
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
int unregister_binfmt(FAR struct binfmt_s *binfmt);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: load_module
|
||||
*
|
||||
* Description:
|
||||
* Load a module into memory, bind it to an exported symbol take, and
|
||||
* prep the module for execution.
|
||||
*
|
||||
* Returned Value:
|
||||
* This is an end-user function, so it follows the normal convention:
|
||||
* Returns 0 (OK) on success. On failure, it returns -1 (ERROR) with
|
||||
* errno set appropriately.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
int load_module(FAR struct binary_s *bin);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: unload_module
|
||||
*
|
||||
* Description:
|
||||
* Unload a (non-executing) module from memory. If the module has
|
||||
* been started (via exec_module) and has not exited, calling this will
|
||||
* be fatal.
|
||||
*
|
||||
* However, this function must be called after the module exist. How
|
||||
* this is done is up to your logic. Perhaps you register it to be
|
||||
* called by on_exit()?
|
||||
*
|
||||
* Returned Value:
|
||||
* This is a NuttX internal function so it follows the convention that
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
int unload_module(FAR const struct binary_s *bin);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: exec_module
|
||||
*
|
||||
* Description:
|
||||
* Execute a module that has been loaded into memory by load_module().
|
||||
*
|
||||
* Returned Value:
|
||||
* This is an end-user function, so it follows the normal convention:
|
||||
* Returns the PID of the exec'ed module. On failure, it.returns
|
||||
* -1 (ERROR) and sets errno appropriately.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
int exec_module(FAR const struct binary_s *bin, int priority);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: exec
|
||||
*
|
||||
* Description:
|
||||
* This is a convenience function that wraps load_ and exec_module into
|
||||
* one call.
|
||||
*
|
||||
* Input Parameter:
|
||||
* filename - Fulll path to the binary to be loaded
|
||||
* argv - Argument list
|
||||
* exports - Table of exported symbols
|
||||
* nexports - The number of symbols in exports
|
||||
*
|
||||
* Returned Value:
|
||||
* This is an end-user function, so it follows the normal convention:
|
||||
* Returns the PID of the exec'ed module. On failure, it.returns
|
||||
* -1 (ERROR) and sets errno appropriately.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
int exec(FAR const char *filename, FAR const char **argv,
|
||||
FAR const struct symtab_s *exports, int nexports);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: exepath_init
|
||||
*
|
||||
* Description:
|
||||
* Initialize for the traversal of each value in the PATH variable. The
|
||||
* usage is sequence is as follows:
|
||||
*
|
||||
* 1) Call exepath_init() to initialize for the traversal. exepath_init()
|
||||
* will return an opaque handle that can then be provided to
|
||||
* exepath_next() and exepath_release().
|
||||
* 2) Call exepath_next() repeatedly to examine every file that lies
|
||||
* in the directories of the PATH variable
|
||||
* 3) Call exepath_release() to free resources set aside by exepath_init().
|
||||
*
|
||||
* Input Parameters:
|
||||
* None
|
||||
*
|
||||
* Returned Value:
|
||||
* On success, exepath_init() return a non-NULL, opaque handle that may
|
||||
* subsequently be used in calls to exepath_next() and exepath_release().
|
||||
* On error, a NULL handle value will be returned. The most likely cause
|
||||
* of an error would be that the there is no value associated with the
|
||||
* PATH variable.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#if !defined(CONFIG_BINFMT_DISABLE) && defined(CONFIG_BINFMT_EXEPATH)
|
||||
EXEPATH_HANDLE exepath_init(void);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: exepath_next
|
||||
*
|
||||
* Description:
|
||||
* Traverse all possible values in the PATH variable in attempt to find
|
||||
* the full path to an executable file when only a relative path is
|
||||
* provided.
|
||||
*
|
||||
* Input Parameters:
|
||||
* handle - The handle value returned by exepath_init
|
||||
* relpath - The relative path to the file to be found.
|
||||
*
|
||||
* Returned Value:
|
||||
* On success, a non-NULL pointer to a null-terminated string is provided.
|
||||
* This is the full path to a file that exists in the file system. This
|
||||
* function will verify that the file exists (but will not verify that it
|
||||
* is marked executable).
|
||||
*
|
||||
* NOTE: The string pointer return in the success case points to allocated
|
||||
* memory. This memory must be freed by the called by calling kfree().
|
||||
*
|
||||
* NULL is returned if no path is found to any file with the provided
|
||||
* 'relpath' from any absolute path in the PATH variable. In this case,
|
||||
* there is no point in calling exepath_next() further; exepath_release()
|
||||
* must be called to release resources set aside by expath_init().
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#if !defined(CONFIG_BINFMT_DISABLE) && defined(CONFIG_BINFMT_EXEPATH)
|
||||
FAR char *exepath_next(EXEPATH_HANDLE handle, FAR const char *relpath);
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Name: exepath_release
|
||||
*
|
||||
* Description:
|
||||
* Release all resources set aside by exepath_init() when the handle value
|
||||
* was created. The handle value is invalid on return from this function.
|
||||
* Attempts to all exepath_next() or exepath_release() with such a 'stale'
|
||||
* handle will result in undefined (i.e., not good) behavior.
|
||||
*
|
||||
* Input Parameters:
|
||||
* handle - The handle value returned by exepath_init
|
||||
*
|
||||
* Returned Value:
|
||||
* None
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#if !defined(CONFIG_BINFMT_DISABLE) && defined(CONFIG_BINFMT_EXEPATH)
|
||||
void exepath_release(EXEPATH_HANDLE handle);
|
||||
#endif
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __INCLUDE_NUTTX_BINFMT_BINFMT_H */
|
||||
|
||||
@@ -0,0 +1,340 @@
|
||||
/****************************************************************************
|
||||
* include/nuttx/binfmt/elf.h
|
||||
*
|
||||
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
|
||||
* Author: Gregory Nutt <gnutt@nuttx.org>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __INCLUDE_NUTTX_BINFMT_ELF_H
|
||||
#define __INCLUDE_NUTTX_BINFMT_ELF_H
|
||||
|
||||
/****************************************************************************
|
||||
* Included Files
|
||||
****************************************************************************/
|
||||
|
||||
#include <nuttx/config.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <elf32.h>
|
||||
|
||||
#include <nuttx/binfmt/binfmt.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Pre-processor Definitions
|
||||
****************************************************************************/
|
||||
/* Configuration ************************************************************/
|
||||
|
||||
#ifndef CONFIG_ELF_ALIGN_LOG2
|
||||
# define CONFIG_ELF_ALIGN_LOG2 2
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ELF_STACKSIZE
|
||||
# define CONFIG_ELF_STACKSIZE 2048
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ELF_BUFFERSIZE
|
||||
# define CONFIG_ELF_BUFFERSIZE 128
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_ELF_BUFFERINCR
|
||||
# define CONFIG_ELF_BUFFERINCR 32
|
||||
#endif
|
||||
|
||||
/* Allocation array size and indices */
|
||||
|
||||
#define LIBELF_ELF_ALLOC 0
|
||||
#ifdef CONFIG_BINFMT_CONSTRUCTORS
|
||||
# define LIBELF_CTORS_ALLOC 1
|
||||
# define LIBELF_CTPRS_ALLOC 2
|
||||
# define LIBELF_NALLOC 3
|
||||
#else
|
||||
# define LIBELF_NALLOC 1
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* Public Types
|
||||
****************************************************************************/
|
||||
|
||||
/* This struct provides a desciption of the currently loaded instantiation
|
||||
* of an ELF binary.
|
||||
*/
|
||||
|
||||
struct elf_loadinfo_s
|
||||
{
|
||||
/* elfalloc is the base address of the memory that is allocated to hold the
|
||||
* ELF program image.
|
||||
*
|
||||
* If CONFIG_ADDRENV=n, elfalloc will be allocated using kmalloc() (or
|
||||
* kzalloc()). If CONFIG_ADDRENV-y, then elfalloc will be allocated using
|
||||
* up_addrenv_create(). In either case, there will be a unique instance
|
||||
* of elfalloc (and stack) for each instance of a process.
|
||||
*
|
||||
* The alloc[] array in struct binary_s will hold memory that persists after
|
||||
* the ELF module has been loaded.
|
||||
*/
|
||||
|
||||
uintptr_t elfalloc; /* Memory allocated when ELF file was loaded */
|
||||
size_t elfsize; /* Size of the ELF memory allocation */
|
||||
off_t filelen; /* Length of the entire ELF file */
|
||||
Elf32_Ehdr ehdr; /* Buffered ELF file header */
|
||||
FAR Elf32_Shdr *shdr; /* Buffered ELF section headers */
|
||||
uint8_t *iobuffer; /* File I/O buffer */
|
||||
|
||||
/* Constructors and destructors */
|
||||
|
||||
#ifdef CONFIG_BINFMT_CONSTRUCTORS
|
||||
FAR void *ctoralloc; /* Memory allocated for ctors */
|
||||
FAR void *dtoralloc; /* Memory allocated dtors */
|
||||
FAR binfmt_ctor_t *ctors; /* Pointer to a list of constructors */
|
||||
FAR binfmt_dtor_t *dtors; /* Pointer to a list of destructors */
|
||||
uint16_t nctors; /* Number of constructors */
|
||||
uint16_t ndtors; /* Number of destructors */
|
||||
#endif
|
||||
|
||||
/* Address environment.
|
||||
*
|
||||
* addrenv - This is the handle created by up_addrenv_create() that can be
|
||||
* used to manage the tasks address space.
|
||||
* oldenv - This is a value returned by up_addrenv_select() that must be
|
||||
* used to restore the current hardware address environment.
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
task_addrenv_t addrenv; /* Task address environment */
|
||||
hw_addrenv_t oldenv; /* Saved hardware address environment */
|
||||
#endif
|
||||
|
||||
uint16_t symtabidx; /* Symbol table section index */
|
||||
uint16_t strtabidx; /* String table section index */
|
||||
uint16_t buflen; /* size of iobuffer[] */
|
||||
int filfd; /* Descriptor for the file being loaded */
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
* Public Functions
|
||||
****************************************************************************/
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
#define EXTERN extern "C"
|
||||
extern "C" {
|
||||
#else
|
||||
#define EXTERN extern
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* These are APIs exported by libelf (but are used only by the binfmt logic):
|
||||
****************************************************************************/
|
||||
|
||||
/****************************************************************************
|
||||
* Name: elf_init
|
||||
*
|
||||
* Description:
|
||||
* This function is called to configure the library to process an ELF
|
||||
* program binary.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int elf_init(FAR const char *filename,
|
||||
FAR struct elf_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: elf_uninit
|
||||
*
|
||||
* Description:
|
||||
* Releases any resources committed by elf_init(). This essentially
|
||||
* undoes the actions of elf_init.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int elf_uninit(FAR struct elf_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: elf_load
|
||||
*
|
||||
* Description:
|
||||
* Loads the binary into memory, allocating memory, performing relocations
|
||||
* and inializing the data and bss segments.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int elf_load(FAR struct elf_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: elf_bind
|
||||
*
|
||||
* Description:
|
||||
* Bind the imported symbol names in the loaded module described by
|
||||
* 'loadinfo' using the exported symbol values provided by 'symtab'.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
struct symtab_s;
|
||||
EXTERN int elf_bind(FAR struct elf_loadinfo_s *loadinfo,
|
||||
FAR const struct symtab_s *exports, int nexports);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: elf_unload
|
||||
*
|
||||
* Description:
|
||||
* This function unloads the object from memory. This essentially undoes
|
||||
* the actions of elf_load. It is called only under certain error
|
||||
* conditions after the the module has been loaded but not yet started.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int elf_unload(struct elf_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* These are APIs used outside of binfmt by NuttX:
|
||||
****************************************************************************/
|
||||
/****************************************************************************
|
||||
* Name: elf_initialize
|
||||
*
|
||||
* Description:
|
||||
* ELF support is built unconditionally. However, it order to
|
||||
* use this binary format, this function must be called during system
|
||||
* format in order to register the ELF binary format.
|
||||
*
|
||||
* Returned Value:
|
||||
* This is a NuttX internal function so it follows the convention that
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int elf_initialize(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: elf_uninitialize
|
||||
*
|
||||
* Description:
|
||||
* Unregister the ELF binary loader
|
||||
*
|
||||
* Returned Value:
|
||||
* None
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void elf_uninitialize(void);
|
||||
|
||||
/****************************************************************************
|
||||
* These are APIs must be provided by architecture-specific logic:
|
||||
****************************************************************************/
|
||||
/****************************************************************************
|
||||
* Name: arch_checkarch
|
||||
*
|
||||
* Description:
|
||||
* Given the ELF header in 'hdr', verify that the ELF file is appropriate
|
||||
* for the current, configured architecture. Every architecture that uses
|
||||
* the ELF loader must provide this function.
|
||||
*
|
||||
* Input Parameters:
|
||||
* hdr - The ELF header read from the ELF file.
|
||||
*
|
||||
* Returned Value:
|
||||
* True if the architecture supports this ELF file.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN bool arch_checkarch(FAR const Elf32_Ehdr *hdr);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: arch_relocate and arch_relocateadd
|
||||
*
|
||||
* Description:
|
||||
* Perform on architecture-specific ELF relocation. Every architecture
|
||||
* that uses the ELF loader must provide this function.
|
||||
*
|
||||
* Input Parameters:
|
||||
* rel - The relocation type
|
||||
* sym - The ELF symbol structure containing the fully resolved value.
|
||||
* addr - The address that requires the relocation.
|
||||
*
|
||||
* Returned Value:
|
||||
* Zero (OK) if the relocation was successful. Otherwise, a negated errno
|
||||
* value indicating the cause of the relocation failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int arch_relocate(FAR const Elf32_Rel *rel, FAR const Elf32_Sym *sym,
|
||||
uintptr_t addr);
|
||||
EXTERN int arch_relocateadd(FAR const Elf32_Rela *rel,
|
||||
FAR const Elf32_Sym *sym, uintptr_t addr);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: arch_flushicache
|
||||
*
|
||||
* Description:
|
||||
* Flush the instruction cache.
|
||||
*
|
||||
* Input Parameters:
|
||||
* addr - Start address to flush
|
||||
* len - Number of bytes to flush
|
||||
*
|
||||
* Returned Value:
|
||||
* True if the architecture supports this ELF file.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef CONFIG_ELF_ICACHE
|
||||
EXTERN bool arch_flushicache(FAR void *addr, size_t len);
|
||||
#endif
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __INCLUDE_NUTTX_BINFMT_ELF_H */
|
||||
@@ -0,0 +1,287 @@
|
||||
/****************************************************************************
|
||||
* include/nuttx/binfmt/nxflat.h
|
||||
*
|
||||
* Copyright (C) 2009, 2012 Gregory Nutt. All rights reserved.
|
||||
* Author: Gregory Nutt <gnutt@nuttx.org>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef __INCLUDE_NUTTX_BINFMT_NXFLAT_H
|
||||
#define __INCLUDE_NUTTX_BINFMT_NXFLAT_H
|
||||
|
||||
/****************************************************************************
|
||||
* Included Files
|
||||
****************************************************************************/
|
||||
|
||||
#include <nuttx/config.h>
|
||||
|
||||
#include <stdint.h>
|
||||
#include <nxflat.h>
|
||||
|
||||
#include <nuttx/sched.h>
|
||||
#include <nuttx/arch.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Pre-processor Definitions
|
||||
****************************************************************************/
|
||||
|
||||
/****************************************************************************
|
||||
* Public Types
|
||||
****************************************************************************/
|
||||
|
||||
/* This struct provides a desciption of the currently loaded instantiation
|
||||
* of an nxflat binary.
|
||||
*/
|
||||
|
||||
struct nxflat_loadinfo_s
|
||||
{
|
||||
/* Instruction Space (ISpace): This region contains the nxflat file header
|
||||
* plus everything from the text section.
|
||||
*
|
||||
* The ISpace region is allocated using mmap() and, thus, can be shared by
|
||||
* multiple tasks. Ideally, will have only one mmap'ed text section
|
||||
* instance in the system for each module.
|
||||
*/
|
||||
|
||||
uintptr_t ispace; /* Address where hdr/text is loaded */
|
||||
uint32_t entryoffs; /* Offset from ispace to entry point */
|
||||
uint32_t isize; /* Size of ispace. */
|
||||
|
||||
/* Data Space (DSpace): This region contains all information that is
|
||||
* referenced as data (other than the stack which is separately allocated).
|
||||
*
|
||||
* If CONFIG_ADDRENV=n, DSpace will be allocated using kmalloc() (or
|
||||
* kzalloc()). If CONFIG_ADDRENV-y, then DSpace will be allocated using
|
||||
* up_addrenv_create(). In either case, there will be a unique instance
|
||||
* of DSpace (and stack) for each instance of a process.
|
||||
*/
|
||||
|
||||
struct dspace_s *dspace; /* Allocated D-Space (data/bss/etc) */
|
||||
uint32_t datasize; /* Size of data segment in dspace */
|
||||
uint32_t bsssize; /* Size of bss segment in dspace */
|
||||
uint32_t stacksize; /* Size of stack (not allocated) */
|
||||
uint32_t dsize; /* Size of dspace (may be large than parts) */
|
||||
|
||||
/* This is temporary memory where relocation records will be loaded. */
|
||||
|
||||
uint32_t relocstart; /* Start of array of struct flat_reloc */
|
||||
uint16_t reloccount; /* Number of elements in reloc array */
|
||||
|
||||
/* Address environment.
|
||||
*
|
||||
* addrenv - This is the handle created by up_addrenv_create() that can be
|
||||
* used to manage the tasks address space.
|
||||
* oldenv - This is a value returned by up_addrenv_select() that must be
|
||||
* used to restore the current hardware address environment.
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_ADDRENV
|
||||
task_addrenv_t addrenv; /* Task address environment */
|
||||
hw_addrenv_t oldenv; /* Saved hardware address environment */
|
||||
#endif
|
||||
|
||||
/* File descriptors */
|
||||
|
||||
int filfd; /* Descriptor for the file being loaded */
|
||||
|
||||
/* This is a copy of the NXFLAT header (still in network order) */
|
||||
|
||||
struct nxflat_hdr_s header;
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
* Public Functions
|
||||
****************************************************************************/
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
#define EXTERN extern "C"
|
||||
extern "C" {
|
||||
#else
|
||||
#define EXTERN extern
|
||||
#endif
|
||||
|
||||
/****************************************************************************
|
||||
* These are APIs exported by libnxflat (and may be used outside of NuttX):
|
||||
****************************************************************************/
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_verifyheader
|
||||
*
|
||||
* Description:
|
||||
* Given the header from a possible NXFLAT executable, verify that it is
|
||||
* an NXFLAT executable.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_verifyheader(const struct nxflat_hdr_s *header);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_init
|
||||
*
|
||||
* Description:
|
||||
* This function is called to configure the library to process an NXFLAT
|
||||
* program binary.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_init(const char *filename,
|
||||
struct nxflat_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_uninit
|
||||
*
|
||||
* Description:
|
||||
* Releases any resources committed by nxflat_init(). This essentially
|
||||
* undoes the actions of nxflat_init.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_uninit(struct nxflat_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_load
|
||||
*
|
||||
* Description:
|
||||
* Loads the binary specified by nxflat_init into memory, mapping
|
||||
* the I-space executable regions, allocating the D-Space region,
|
||||
* and inializing the data segment (relocation information is
|
||||
* temporarily loaded into the BSS region. BSS will be cleared
|
||||
* by nxflat_bind() after the relocation data has been processed).
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_load(struct nxflat_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_read
|
||||
*
|
||||
* Description:
|
||||
* Read 'readsize' bytes from the object file at 'offset'
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_read(struct nxflat_loadinfo_s *loadinfo, char *buffer,
|
||||
int readsize, int offset);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_bind
|
||||
*
|
||||
* Description:
|
||||
* Bind the imported symbol names in the loaded module described by
|
||||
* 'loadinfo' using the exported symbol values provided by 'symtab'
|
||||
* After binding the module, clear the BSS region (which held the relocation
|
||||
* data) in preparation for execution.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
struct symtab_s;
|
||||
EXTERN int nxflat_bind(FAR struct nxflat_loadinfo_s *loadinfo,
|
||||
FAR const struct symtab_s *exports, int nexports);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_unload
|
||||
*
|
||||
* Description:
|
||||
* This function unloads the object from memory. This essentially undoes
|
||||
* the actions of nxflat_load. It is called only under certain error
|
||||
* conditions after the the module has been loaded but not yet started.
|
||||
*
|
||||
* Returned Value:
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_unload(struct nxflat_loadinfo_s *loadinfo);
|
||||
|
||||
/****************************************************************************
|
||||
* These are APIs used internally only by NuttX:
|
||||
****************************************************************************/
|
||||
/****************************************************************************
|
||||
* Name: nxflat_initialize
|
||||
*
|
||||
* Description:
|
||||
* NXFLAT support is built unconditionally. However, it order to
|
||||
* use this binary format, this function must be called during system
|
||||
* format in order to register the NXFLAT binary format.
|
||||
*
|
||||
* Returned Value:
|
||||
* This is a NuttX internal function so it follows the convention that
|
||||
* 0 (OK) is returned on success and a negated errno is returned on
|
||||
* failure.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN int nxflat_initialize(void);
|
||||
|
||||
/****************************************************************************
|
||||
* Name: nxflat_uninitialize
|
||||
*
|
||||
* Description:
|
||||
* Unregister the NXFLAT binary loader
|
||||
*
|
||||
* Returned Value:
|
||||
* None
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
EXTERN void nxflat_uninitialize(void);
|
||||
|
||||
#undef EXTERN
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __INCLUDE_NUTTX_BINFMT_NXFLAT_H */
|
||||
@@ -255,7 +255,7 @@
|
||||
* external RAM.
|
||||
*/
|
||||
|
||||
#if defined(__z80) || defined(__gbz80)
|
||||
#if defined(__SDCC_z80) || defined(__SDCC_z180) || defined(__SDCC_gbz80)
|
||||
# define FAR
|
||||
# define NEAR
|
||||
# define CODE
|
||||
|
||||
@@ -172,7 +172,7 @@ struct mountpt_operations
|
||||
|
||||
int (*statfs)(FAR struct inode *mountpt, FAR struct statfs *buf);
|
||||
|
||||
/* Operations on pathes */
|
||||
/* Operations on paths */
|
||||
|
||||
int (*unlink)(FAR struct inode *mountpt, FAR const char *relpath);
|
||||
int (*mkdir)(FAR struct inode *mountpt, FAR const char *relpath, mode_t mode);
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
/************************************************************************************
|
||||
* include/nuttx/input/keypad.h
|
||||
*
|
||||
* Copyright (C) 2012 Denis Carikli.
|
||||
* Author: Denis Carikli <GNUtoo@no-log.org>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
************************************************************************************/
|
||||
|
||||
#ifndef __INCLUDE_NUTTX_INPUT_KEYPAD_H
|
||||
#define __INCLUDE_NUTTX_INPUT_KEYPAD_H
|
||||
|
||||
/****************************************************************************
|
||||
* Public Function Prototypes
|
||||
****************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int keypad_kbdinit(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __INCLUDE_NUTTX_INPUT_KEYPAD_H */
|
||||
|
||||
+268
-2
@@ -50,14 +50,280 @@
|
||||
|
||||
#ifdef CONFIG_ARCH_MATH_H
|
||||
# include <arch/math.h>
|
||||
#endif
|
||||
|
||||
/* If CONFIG_LIB is enabled, then the math library at lib/math will be
|
||||
* built. This library was taken from the math library developed for the
|
||||
* Rhombus OS by Nick Johnson (https://github.com/nickbjohnson4224/rhombus).
|
||||
* The port or the Rhombus math library was contributed by Darcy Gong.
|
||||
*/
|
||||
|
||||
#else if defined CONFIG_LIBM
|
||||
|
||||
/****************************************************************************
|
||||
* Type Definitions
|
||||
* Copyright (C) 2009-2011 Nick Johnson <nickbjohnson4224 at gmail.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/****************************************************************************
|
||||
* Included Files
|
||||
****************************************************************************/
|
||||
|
||||
#include <nuttx/config.h>
|
||||
#include <nuttx/compiler.h>
|
||||
|
||||
/****************************************************************************
|
||||
* Pre-processor Definitions
|
||||
****************************************************************************/
|
||||
|
||||
/* General Constants ********************************************************/
|
||||
|
||||
#define INFINITY (1.0/0.0)
|
||||
#define NAN (0.0/0.0)
|
||||
#define HUGE_VAL INFINITY
|
||||
|
||||
#define isnan(x) ((x) != (x))
|
||||
#define isinf(x) (((x) == INFINITY) || ((x) == -INFINITY))
|
||||
|
||||
/* Exponential and Logarithmic constants ************************************/
|
||||
|
||||
#define M_E 2.7182818284590452353602874713526625
|
||||
#define M_SQRT2 1.4142135623730950488016887242096981
|
||||
#define M_SQRT1_2 0.7071067811865475244008443621048490
|
||||
#define M_LOG2E 1.4426950408889634073599246810018921
|
||||
#define M_LOG10E 0.4342944819032518276511289189166051
|
||||
#define M_LN2 0.6931471805599453094172321214581765
|
||||
#define M_LN10 2.3025850929940456840179914546843642
|
||||
|
||||
/* Trigonometric Constants **************************************************/
|
||||
|
||||
#define M_PI 3.1415926535897932384626433832795029
|
||||
#define M_PI_2 1.5707963267948966192313216916397514
|
||||
#define M_PI_4 0.7853981633974483096156608458198757
|
||||
#define M_1_PI 0.3183098861837906715377675267450287
|
||||
#define M_2_PI 0.6366197723675813430755350534900574
|
||||
#define M_2_SQRTPI 1.1283791670955125738961589031215452
|
||||
|
||||
/****************************************************************************
|
||||
* Public Function Prototypes
|
||||
****************************************************************************/
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* General Functions ********************************************************/
|
||||
|
||||
float ceilf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double ceil (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double ceill (long double x);
|
||||
#endif
|
||||
|
||||
float floorf(float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double floor (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double floorl(long double x);
|
||||
#endif
|
||||
|
||||
float roundf(float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double round (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double roundl(long double x);
|
||||
#endif
|
||||
|
||||
float fabsf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double fabs (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double fabsl (long double x);
|
||||
#endif
|
||||
|
||||
float modff (float x, float *iptr);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double modf (double x, double *iptr);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double modfl (long double x, long double *iptr);
|
||||
#endif
|
||||
|
||||
float fmodf (float x, float div);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double fmod (double x, double div);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double fmodl (long double x, long double div);
|
||||
#endif
|
||||
|
||||
/* Exponential and Logarithmic Functions ************************************/
|
||||
|
||||
float powf (float b, float e);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double pow (double b, double e);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double powl (long double b, long double e);
|
||||
#endif
|
||||
|
||||
float expf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double exp (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double expl (long double x);
|
||||
#endif
|
||||
|
||||
float logf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double log (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double logl (long double x);
|
||||
#endif
|
||||
|
||||
float log10f(float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double log10 (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double log10l(long double x);
|
||||
#endif
|
||||
|
||||
float log2f (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double log2 (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double log2l (long double x);
|
||||
#endif
|
||||
|
||||
float sqrtf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double sqrt (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double sqrtl (long double x);
|
||||
#endif
|
||||
|
||||
float ldexpf(float x, int n);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double ldexp (double x, int n);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double ldexpl(long double x, int n);
|
||||
#endif
|
||||
|
||||
float frexpf(float x, int *exp);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double frexp (double x, int *exp);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double frexpl(long double x, int *exp);
|
||||
#endif
|
||||
|
||||
/* Trigonometric Functions **************************************************/
|
||||
|
||||
float sinf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double sin (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double sinl (long double x);
|
||||
#endif
|
||||
|
||||
float cosf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double cos (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double cosl (long double x);
|
||||
#endif
|
||||
|
||||
float tanf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double tan (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double tanl (long double x);
|
||||
#endif
|
||||
|
||||
float asinf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double asin (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double asinl (long double x);
|
||||
#endif
|
||||
|
||||
float acosf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double acos (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double acosl (long double x);
|
||||
#endif
|
||||
|
||||
float atanf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double atan (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double atanl (long double x);
|
||||
#endif
|
||||
|
||||
float atan2f(float y, float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double atan2 (double y, double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double atan2l(long double y, long double x);
|
||||
#endif
|
||||
|
||||
float sinhf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double sinh (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double sinhl (long double x);
|
||||
#endif
|
||||
|
||||
float coshf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double cosh (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double coshl (long double x);
|
||||
#endif
|
||||
|
||||
float tanhf (float x);
|
||||
#if CONFIG_HAVE_DOUBLE
|
||||
double tanh (double x);
|
||||
#endif
|
||||
#ifdef CONFIG_HAVE_LONG_DOUBLE
|
||||
long double tanhl (long double x);
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CONFIG_LIBM */
|
||||
#endif /* __INCLUDE_NUTTX_MATH_H */
|
||||
|
||||
@@ -220,7 +220,6 @@ EXTERN FAR struct mtd_dev_s *at24c_initialize(FAR struct i2c_dev_s *dev);
|
||||
|
||||
EXTERN FAR struct mtd_dev_s *sst25_initialize(FAR struct spi_dev_s *dev);
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* Name: w25_initialize
|
||||
*
|
||||
@@ -233,6 +232,8 @@ EXTERN FAR struct mtd_dev_s *sst25_initialize(FAR struct spi_dev_s *dev);
|
||||
|
||||
EXTERN FAR struct mtd_dev_s *w25_initialize(FAR struct spi_dev_s *dev);
|
||||
|
||||
EXTERN FAR struct mtd_dev_s *at25_initialize(FAR struct spi_dev_s *dev);
|
||||
|
||||
#undef EXTERN
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@@ -163,24 +163,40 @@ typedef struct environ_s environ_t;
|
||||
# define SIZEOF_ENVIRON_T(alloc) (sizeof(environ_t) + alloc - 1)
|
||||
#endif
|
||||
|
||||
/* This structure describes a reference counted D-Space region */
|
||||
/* This structure describes a reference counted D-Space region. This must be a
|
||||
* separately allocated "break-away" structure that can be owned by a task and
|
||||
* any pthreads created by the task.
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_PIC
|
||||
struct dspace_s
|
||||
{
|
||||
uint32_t crefs; /* This is the number of pthreads that shared the
|
||||
* the same D-Space */
|
||||
uint8_t region[1]; /* Beginning of the allocated region */
|
||||
/* The life of the structure allocation is determined by this reference
|
||||
* count. This count is number of threads that shared the the same D-Space.
|
||||
* This includes the parent task as well as any pthreads created by the
|
||||
* parent task or any of its child threads.
|
||||
*/
|
||||
|
||||
uint16_t crefs;
|
||||
|
||||
/* This is the allocated D-Space memory region. This may be a physical
|
||||
* address allocated with kmalloc(), or it may be virtual address associated
|
||||
* with an address environment (if CONFIG_ADDRENV=y).
|
||||
*/
|
||||
|
||||
FAR uint8_t *region;
|
||||
};
|
||||
#endif
|
||||
|
||||
#define SIZEOF_DSPACE_S(n) (sizeof(struct dspace_s) - 1 + (n))
|
||||
|
||||
/* This is the task control block (TCB) */
|
||||
/* This is the task control block (TCB). Each task or thread is represented by
|
||||
* a TCB. The TCB is the heart of the NuttX task-control logic.
|
||||
*/
|
||||
|
||||
struct _TCB
|
||||
{
|
||||
/* Fields used to support list management *************************************/
|
||||
|
||||
FAR struct _TCB *flink; /* link in DQ of TCBs */
|
||||
FAR struct _TCB *flink; /* Doubly linked list */
|
||||
FAR struct _TCB *blink;
|
||||
|
||||
/* Task Management Fields *****************************************************/
|
||||
|
||||
@@ -179,8 +179,8 @@
|
||||
#define VT52_CLEAREOL {ASCII_ESC, 'K'} /* Erase to end of current line */
|
||||
#define VT52_CLEAREOS {ASCII_ESC, 'J'} /* Erase to end of screen */
|
||||
|
||||
#define VT52_IDENT {ASCII_ESC, 'Z'} /* dentify what the terminal is */
|
||||
#define VT52_IDENTRESP {ASCII_ESC, '/', 'Z'} /* Correct response to ident */
|
||||
#define VT52_IDENT {ASCII_ESC, 'Z'} /* Identify what the terminal is */
|
||||
#define VT52_IDENTRESP {ASCII_ESC, '/', 'Z'} /* Correct response to ident */
|
||||
|
||||
/* VT100 Special Key Codes
|
||||
*
|
||||
|
||||
+33
-2
@@ -42,10 +42,33 @@
|
||||
|
||||
#include <nuttx/config.h>
|
||||
|
||||
/* If CONFIG_ARCH_STDBOOL_H is set, then the archecture will provide its own
|
||||
* stdbool.h file. In this case, this header file will simply re-direct to
|
||||
* the architecture-specfiic stdbool.h header file.
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_ARCH_STDBOOL_H
|
||||
# include <arch/stdbool.h>
|
||||
|
||||
/* NuttX will insist that the sizeof(bool) is 8-bits. The sizeof of _Bool
|
||||
* used by any specific compiler is implementation specific: It can vary from
|
||||
* compiler-to-compiler and even vary between different versions of the same
|
||||
* compiler. Compilers seems to be converging to sizeof(_Bool) == 1. If that
|
||||
* is true for your compiler, you should define CONFIG_C99_BOOL8 in your NuttX
|
||||
* configuration for better standards compatibility.
|
||||
*
|
||||
* CONFIG_C99_BOOL8 - Means (1) your C++ compiler has sizeof(_Bool) == 8,
|
||||
* (2) your C compiler supports the C99 _Bool intrinsic type, and (2) that
|
||||
* the C99 _Bool type also has size 1.
|
||||
*/
|
||||
|
||||
#else
|
||||
|
||||
/* nuttx/compiler.h may also define or undefine CONFIG_C99_BOOL8 */
|
||||
|
||||
# include <nuttx/compiler.h>
|
||||
|
||||
#if !defined(__cplusplus) || !defined(CONFIG_C99_BOOL8)
|
||||
# include <stdint.h>
|
||||
|
||||
/****************************************************************************
|
||||
@@ -58,10 +81,15 @@
|
||||
* NOTE: Under C99 'bool' is required to be defined to be the intrinsic type
|
||||
* _Bool. However, in this NuttX context, we need backward compatibility
|
||||
* to pre-C99 standards where _Bool is not an intrinsic type. Hence, we
|
||||
* use _Bool8 as the underlying type.
|
||||
* use _Bool8 as the underlying type (unless CONFIG_C99_BOOL8 is defined)
|
||||
*/
|
||||
|
||||
#define bool _Bool8
|
||||
#ifdef CONFIG_C99_BOOL8
|
||||
# define bool _Bool
|
||||
#else
|
||||
# define bool _Bool8
|
||||
#endif
|
||||
|
||||
#define true 1
|
||||
#define false 0
|
||||
|
||||
@@ -83,7 +111,10 @@
|
||||
* as the underlying type.
|
||||
*/
|
||||
|
||||
#ifndef CONFIG_C99_BOOL8
|
||||
typedef uint8_t _Bool8;
|
||||
#endif
|
||||
|
||||
#endif /* __cplusplus && CONFIG_C99_BOOL8 */
|
||||
#endif /* CONFIG_ARCH_STDBOOL_H */
|
||||
#endif /* __INCLUDE_STDBOOL_H */
|
||||
|
||||
Reference in New Issue
Block a user