takashi kadono / Mbed OS Nucleo_446

Dependencies:   ssd1331

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers mbed_error.h Source File

mbed_error.h

00001 /** \addtogroup platform */
00002 /** @{*/
00003 /**
00004  * \defgroup platform_error Error functions
00005  * @{
00006  */
00007 /* mbed Microcontroller Library
00008  * Copyright (c) 2006-2013 ARM Limited
00009  *
00010  * Licensed under the Apache License, Version 2.0 (the "License");
00011  * you may not use this file except in compliance with the License.
00012  * You may obtain a copy of the License at
00013  *
00014  *     http://www.apache.org/licenses/LICENSE-2.0
00015  *
00016  * Unless required by applicable law or agreed to in writing, software
00017  * distributed under the License is distributed on an "AS IS" BASIS,
00018  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00019  * See the License for the specific language governing permissions and
00020  * limitations under the License.
00021  */
00022 #ifndef MBED_ERROR_H
00023 #define MBED_ERROR_H
00024 
00025 #include "platform/mbed_retarget.h"
00026 #include "platform/mbed_toolchain.h"
00027 
00028 #ifdef __cplusplus
00029 extern "C" {
00030 #endif
00031 
00032 /** Define this macro to include filenames in error context. For release builds, do not include filename to save memory.
00033  *  MBED_PLATFORM_CONF_ERROR_FILENAME_CAPTURE_ENABLED
00034  */
00035 
00036 /** Define this macro to enable error history
00037  *  MBED_PLATFORM_CONF_ERROR_HIST_ENABLED
00038  */
00039 
00040 #ifndef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
00041 #define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN            16
00042 #else //MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
00043 #if MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN > 64
00044 //We have to limit this to 64 bytes since we use mbed_error_printf for error reporting
00045 //and mbed_error_vfprintf uses 128bytes internal buffer which may not be sufficient for anything
00046 //longer that 64 bytes with the current implementation.
00047 #error "Unsupported error filename buffer length detected, max supported length is 64 chars. Please change MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN or max-error-filename-len in configuration."
00048 #endif
00049 #endif
00050 
00051 #define MBED_ERROR_STATUS_CODE_MASK                 (0x0000FFFF)
00052 #define MBED_ERROR_STATUS_CODE_POS                  (0)
00053 #define MBED_ERROR_STATUS_CODE_FIELD_SIZE           (16)
00054 
00055 #define MBED_ERROR_STATUS_MODULE_MASK               (0x00FF0000)
00056 #define MBED_ERROR_STATUS_MODULE_POS                (16)
00057 #define MBED_ERROR_STATUS_MODULE_FIELD_SIZE         (8)
00058 
00059 #define MBED_ERROR_STATUS_TYPE_MASK                 (0x60000000)
00060 #define MBED_ERROR_STATUS_TYPE_POS                  (29)
00061 #define MBED_ERROR_STATUS_TYPE_FIELD_SIZE           (2)
00062 
00063 /* mbed_error_status_t Status Encoding */
00064 //|31(1 bit) Always Negative|30-29(2 bits)  |28-24              | 23-16(8 bits) |  15-0(16 bits) |
00065 //|-1                       |TYPE           |(unused/reserved)  | MODULE TYPE   |  ERROR CODE    |
00066 
00067 #define MAKE_MBED_ERROR(type, module, error_code)   (mbed_error_status_t)                                                                   \
00068                                                     ((0x80000000) |                                                                     \
00069                                                     (MBED_ERROR_STATUS_CODE_MASK & (error_code << MBED_ERROR_STATUS_CODE_POS)) |        \
00070                                                     (MBED_ERROR_STATUS_MODULE_MASK & (module << MBED_ERROR_STATUS_MODULE_POS)) |        \
00071                                                     (MBED_ERROR_STATUS_TYPE_MASK & (type << MBED_ERROR_STATUS_TYPE_POS)))
00072 
00073 #define MBED_GET_ERROR_TYPE( error_status )         ((error_status & MBED_ERROR_STATUS_TYPE_MASK) >> MBED_ERROR_STATUS_TYPE_POS)
00074 #define MBED_GET_ERROR_MODULE( error_status )       ((error_status & MBED_ERROR_STATUS_MODULE_MASK) >> MBED_ERROR_STATUS_MODULE_POS)
00075 #define MBED_GET_ERROR_CODE( error_status )         (int)((MBED_GET_ERROR_TYPE( error_status ) == MBED_ERROR_TYPE_POSIX)?(-error_status):((error_status & MBED_ERROR_STATUS_CODE_MASK) >> MBED_ERROR_STATUS_CODE_POS))
00076 
00077 /** mbed_error_status_t description
00078  *
00079  * mbed_error_status_t type represents the error status values under MbedOS. mbed_error_status_t values are signed integers and always be negative.\n
00080  * Internally its encoded as below with bit-fields representing error type, module and error code:\n\n
00081  * mbed_error_status_t Status Encoding:\n
00082  *
00083  \verbatim
00084  | 31 Always Negative | 30-29(2 bits)  | 28-24              | 23-16(8 bits) | 15-0(16 bits) |
00085  | -1                 | TYPE           | (unused/reserved)  | MODULE TYPE    | ERROR CODE    |
00086  \endverbatim
00087  *
00088  * The error status value range for each error type is as follows:\n
00089  *   Posix Error Status-es  - 0xFFFFFFFF to 0xFFFFFF01(-1 -255) - This corresponds to Posix error codes represented as negative.\n
00090  *   System Error Status-es - 0x80XX0100 to 0x80XX0FFF - This corresponds to System error codes range(all values are negative). Bits 23-16 will be module type(marked with XX)\n
00091  *   Custom Error Status-es - 0xA0XX1000 to 0xA0XXFFFF - This corresponds to Custom error codes range(all values are negative). Bits 23-16 will be module type(marked with XX)\n\n
00092  *
00093  * The ERROR CODE(values encoded into ERROR CODE bit-field in mbed_error_status_t) value range for each error type is also seperated as below:\n
00094  *   Posix Error Codes  - 1 to 255.\n
00095  *   System Error Codes - 256 to 4095.\n
00096  *   Custom Error Codes - 4096 to 65535.\n
00097  *
00098  * @note Posix error codes are always encoded as negative of their actual value. For example, EPERM is encoded as -EPERM.
00099  *       And, the MODULE TYPE for Posix error codes are always encoded as MBED_MODULE_UNKNOWN.\n
00100  *       This is to enable easy injection of Posix error codes into MbedOS error handling system without altering the actual Posix error values.\n
00101  *       Accordingly, Posix error codes are represented as -1 to -255 under MbedOS error status representation.
00102  */
00103 typedef int mbed_error_status_t;
00104 
00105 /**
00106  * Macro for defining a Posix error status. This macro is mainly used to define Posix error values in mbed_error_code_t enumeration.
00107  * @param  error_name       Name of the error without the ERROR_ prefix
00108  * @param  error_code       Error code value to be used, must be between 1 and 255(inclusive).
00109  *
00110  */
00111 #define MBED_DEFINE_POSIX_ERROR( error_name, error_code )   \
00112                      MBED_ERROR_CODE_##error_name = error_code,  \
00113                      MBED_ERROR_##error_name = -(MBED_POSIX_ERROR_BASE + error_code)
00114 
00115 /**
00116  * Macro for defining a System error status. This macro is used to define System error values in mbed_error_code_t enumeration.
00117  * @param  error_name       Name of the error without the ERROR_ prefix
00118  * @param  error_code       Error code value to be used, must be between 256 and 4096(inclusive).
00119  *
00120  */
00121 #define MBED_DEFINE_SYSTEM_ERROR( error_name, error_code )   \
00122                       MBED_ERROR_CODE_##error_name = MBED_SYSTEM_ERROR_BASE + error_code,  \
00123                       MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
00124 
00125 /**
00126  * Macro for defining a Custom error status. This macro is used to define custom error values in mbed_error_code_t enumeration.
00127  * @param  error_name       Name of the error without the ERROR_ prefix
00128  * @param  error_code       Error code value to be used, must be between 4097 and 65535(inclusive).
00129  *
00130  */
00131 #define MBED_DEFINE_CUSTOM_ERROR( error_name, error_code )   \
00132                       MBED_ERROR_CODE_##error_name = MBED_CUSTOM_ERROR_BASE + error_code,  \
00133                       MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
00134 
00135 
00136 /**
00137  * Macros for setting a system warning. These macros will log the error, Its a wrapper for calling mbed_warning API.
00138  * There are 2 versions of this macro. MBED_WARNING takes status and message. MBED_WARNING1 takes an additional context specific argument
00139  * @param  error_status     mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
00140  * @param  error_msg        The error message to be printed out to STDIO/Serial.
00141  * @param  error_value      Value associated with the error status. This would depend on error code/error scenario.
00142  *
00143  * @code
00144  *
00145  * MBED_WARNING( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read" )
00146  * MBED_WARNING1( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read", size_val )
00147  *
00148  * @endcode
00149  * @note The macro calls mbed_warning API with filename and line number info without caller explicitly passing them.
00150  *        Since this macro is a wrapper for mbed_warning API callers should process the return value from this macro which is the return value from calling mbed_error API.
00151  *
00152  */
00153 #ifdef NDEBUG
00154 #define MBED_WARNING1( error_status, error_msg, error_value )         mbed_warning( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 )
00155 #define MBED_WARNING( error_status, error_msg )                       mbed_warning( error_status, (const char *)NULL, (uint32_t)0,           NULL, 0 )
00156 #else //NDEBUG
00157 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
00158 #define MBED_WARNING1( error_status, error_msg, error_value )     mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, (const char *)MBED_FILENAME, __LINE__ )
00159 #define MBED_WARNING( error_status, error_msg )                   mbed_warning( error_status, (const char *)error_msg, (uint32_t)0          , (const char *)MBED_FILENAME, __LINE__ )
00160 #else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
00161 #define MBED_WARNING1( error_status, error_msg, error_value )     mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 )
00162 #define MBED_WARNING( error_status, error_msg )                   mbed_warning( error_status, (const char *)error_msg, (uint32_t)0,           NULL, 0 )
00163 #endif
00164 #endif
00165 
00166 /**
00167  * Macros for setting a fatal system error. These macros will log the error, prints the error report and halts the system. Its a wrapper for calling mbed_error API.
00168  * There are 2 versions of this macro. MBED_ERROR takes status and message. MBED_ERROR1 takes an additional context specific argument
00169  * @param  error_status     mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
00170  * @param  error_msg        The error message to be printed out to STDIO/Serial.
00171  * @param  error_value      Value associated with the error status. This would depend on error code/error scenario. Only available with MBED_ERROR1
00172  * @return                  0 or MBED_SUCCESS.
00173  *                          MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
00174  *
00175  * @code
00176  *
00177  * MBED_ERROR( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex" )
00178  * MBED_ERROR1( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex", &my_mutex )
00179  *
00180  * @endcode
00181  * @note The macro calls mbed_error API with filename and line number info without caller explicitly passing them.
00182  *       Since this macro is a wrapper for mbed_error API callers should process the return value from this macro which is the return value from calling mbed_error API.
00183  *
00184  */
00185 #ifdef NDEBUG
00186 #define MBED_ERROR1( error_status, error_msg, error_value )           mbed_error( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 )
00187 #define MBED_ERROR( error_status, error_msg )                         mbed_error( error_status, (const char *)NULL, (uint32_t)0          , NULL, 0 )
00188 #else //NDEBUG
00189 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
00190 #define MBED_ERROR1( error_status, error_msg, error_value )       mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, (const char *)MBED_FILENAME, __LINE__ )
00191 #define MBED_ERROR( error_status, error_msg )                     mbed_error( error_status, (const char *)error_msg, (uint32_t)0          , (const char *)MBED_FILENAME, __LINE__ )
00192 #else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
00193 #define MBED_ERROR1( error_status, error_msg, error_value )       mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 )
00194 #define MBED_ERROR( error_status, error_msg )                     mbed_error( error_status, (const char *)error_msg, (uint32_t)0          , NULL, 0 )
00195 #endif
00196 #endif
00197 
00198 //Error Type definition
00199 /** mbed_error_type_t definition
00200  *  @note
00201  *  This enumeration defines the Error types supported. The value of these enum values will be encoded into mbed_error_status_t TYPE field.\n
00202  *      See mbed_error_status_t description for more info.\n
00203  *         MBED_ERROR_TYPE_SYSTEM - Used to indicate that the error status is of System defined Error type.\n
00204  *         MBED_ERROR_TYPE_CUSTOM - Used to indicate that the error status is of Custom defined Error type.\n
00205  *         MBED_ERROR_TYPE_POSIX  - Used to indicate that the error status is of Posix error type.\n
00206  *
00207  */
00208 typedef enum _mbed_error_type_t {
00209     MBED_ERROR_TYPE_SYSTEM = 0,
00210     MBED_ERROR_TYPE_CUSTOM = 1,
00211     //2 is reserved
00212     //Use 3 for POSIX because we are mapping -1 to -255 to POSIX error codes
00213     //and thus we must use 3 to match the type bits in error status representation which are from 0xFFFFFFFF to 0xFFFFFF00
00214     MBED_ERROR_TYPE_POSIX = 3
00215 } mbed_error_type_t;
00216 
00217 //Module type/id definitions
00218 /** mbed_module_type_t definition
00219  * @note
00220  * This enumeration defines the module types. The value of these enum values will be encoded into mbed_error_status_t MODULE field.\n\n
00221  *      See mbed_error_status_t description for more info.\n
00222  *          MBED_MODULE_UNKNOWN - This module type can be used if caller of the mbed_error/mbed_warning doesn't know who is the actual originator of the error.\n
00223  *                       Other module values can be used to provide more info on who/where the error originated from.\n\n
00224  *                       For example, if I2C driver is the component originating the error you can use MBED_MODULE_DRIVER_I2C to provide more info.\n
00225  *                       Its used in call to MBED_MAKE_ERROR/MBED_MAKE_SYSTEM_ERROR/MBED_MAKE_CUSTOM_ERROR macros.\n
00226  *
00227  * @code
00228  *      Example: mbed_error_status_t i2c_driver_error = MBED_MAKE_ERROR( MBED_MODULE_DRIVER_I2C, MBED_ERROR_CONFIG_UNSUPPORTED );
00229  * @endcode
00230  *
00231  * @note
00232  *  \n Below are the module code mappings:\n
00233     \verbatim
00234     MBED_MODULE_APPLICATION              0       Application
00235     MBED_MODULE_PLATFORM                 1       Platform
00236     MODULE_KERNEL                   2       RTX Kernel
00237     MBED_MODULE_NETWORK_STACK            3       Network stack
00238     MBED_MODULE_HAL                      4       HAL - Hardware Abstraction Layer
00239     MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM         5       Memory Subsystem
00240     MBED_MODULE_FILESYSTEM               6       Filesystem
00241     MBED_MODULE_BLOCK_DEVICE             7       Block device
00242     MBED_MODULE_DRIVER                   8       Driver
00243     MBED_MODULE_DRIVER_SERIAL            9       Serial Driver
00244     MBED_MODULE_DRIVER_RTC               10      RTC Driver
00245     MBED_MODULE_DRIVER_I2C               11      I2C Driver
00246     MODULE_DRIVER_SPI               12      SPI Driver
00247     MODULE_DRIVER_GPIO              13      GPIO Driver
00248     MODULE_DRIVER_ANALOG            14      Analog Driver
00249     MODULE_DRIVER_DIGITAL           15      DigitalIO Driver
00250     MODULE_DRIVER_CAN               16      CAN Driver
00251     MODULE_DRIVER_ETHERNET          17      Ethernet Driver
00252     MODULE_DRIVER_CRC               18      CRC Module
00253     MODULE_DRIVER_PWM               19      PWM Driver
00254     MODULE_DRIVER_QSPI              20      QSPI Driver
00255     MODULE_DRIVER_USB               21      USB Driver
00256     MODULE_TARGET_SDK               22      SDK
00257 
00258     MBED_MODULE_UNKNOWN                  255     Unknown module
00259     \endverbatim
00260  *
00261  */
00262 typedef enum _mbed_module_type {
00263     MBED_MODULE_APPLICATION = 0,
00264     MBED_MODULE_PLATFORM,
00265     MBED_MODULE_KERNEL,
00266     MBED_MODULE_NETWORK_STACK,
00267     MBED_MODULE_HAL,
00268     MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM,
00269     MBED_MODULE_FILESYSTEM,
00270     MBED_MODULE_BLOCK_DEVICE,
00271     MBED_MODULE_DRIVER,
00272     MBED_MODULE_DRIVER_SERIAL,
00273     MBED_MODULE_DRIVER_RTC,
00274     MBED_MODULE_DRIVER_I2C,
00275     MBED_MODULE_DRIVER_SPI,
00276     MBED_MODULE_DRIVER_GPIO,
00277     MBED_MODULE_DRIVER_ANALOG,
00278     MBED_MODULE_DRIVER_DIGITAL,
00279     MBED_MODULE_DRIVER_CAN,
00280     MBED_MODULE_DRIVER_ETHERNET,
00281     MBED_MODULE_DRIVER_CRC,
00282     MBED_MODULE_DRIVER_PWM,
00283     MBED_MODULE_DRIVER_QSPI,
00284     MBED_MODULE_DRIVER_USB,
00285     MBED_MODULE_TARGET_SDK,
00286     MBED_MODULE_BLE,
00287     /* Add More entities here as required */
00288 
00289     MBED_MODULE_UNKNOWN = 255,
00290     MBED_MODULE_MAX = MBED_MODULE_UNKNOWN
00291 } mbed_module_type_t;
00292 
00293 //Use MBED_SUCCESS(=0) or any postive number for successful returns
00294 #define MBED_SUCCESS           0
00295 
00296 #define MBED_POSIX_ERROR_BASE   0
00297 #define MBED_SYSTEM_ERROR_BASE  256
00298 #define MBED_CUSTOM_ERROR_BASE  4096
00299 
00300 //Error Code definitions
00301 /** mbed_error_code_t definition
00302  *
00303  *  mbed_error_code_t enumeration defines the Error codes and Error status values for MBED_MODULE_UNKNOWN.\n
00304  *  It defines all of Posix Error Codes/Statuses and Mbed System Error Codes/Statuses.\n\n
00305  *
00306  *  @note
00307  *  Posix Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n
00308  *  For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This effectively defines the following values:\n
00309  *      ERROR_CODE_EPERM = EPERM\n
00310  *      ERROR_EPERM = -EPERM\n
00311  *
00312  *  Posix Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n
00313  *  For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This macro defines the following values:\n
00314  *      ERROR_CODE_EPERM = MBED_POSIX_ERROR_BASE+EPERM\n
00315  *      ERROR_EPERM = -(MBED_POSIX_ERROR_BASE+EPERM)\n
00316  *  Its effectively equivalent to:\n
00317  *      ERROR_CODE_EPERM = 1\n
00318  *      ERROR_EPERM = -1\n
00319  *  All Posix error codes currently supported by MbedOS(defined in mbed_retarget.h) are defined using the MBED_DEFINE_POSIX_ERROR macro.\n\n
00320  *  Below are the Posic error codes and the description:\n
00321  *  \verbatim
00322     EPERM                      1        Operation not permitted
00323     ENOENT                     2        No such file or directory
00324     ESRCH                      3        No such process
00325     EINTR                      4        Interrupted system call
00326     EIO                        5        I/O error
00327     ENXIO                      6        No such device or address
00328     E2BIG                      7        Argument list too long
00329     ENOEXEC                    8        Exec format error
00330     EBADF                      9        Bad file number
00331     ECHILD                     10       No child processes
00332     EAGAIN                     11       Try again
00333     ENOMEM                     12       Out of memory
00334     EACCES                     13       Permission denied
00335     EFAULT                     14       Bad address
00336     ENOTBLK                    15       Block device required
00337     EBUSY                      16       Device or resource busy
00338     EEXIST                     17       File exists
00339     EXDEV                      18       Cross-device link
00340     ENODEV                     19       No such device
00341     ENOTDIR                    20       Not a directory
00342     EISDIR                     21       Is a directory
00343     EINVAL                     22       Invalid argument
00344     ENFILE                     23       File table overflow
00345     EMFILE                     24       Too many open files
00346     ENOTTY                     25       Not a typewriter
00347     ETXTBSY                    26       Text file busy
00348     EFBIG                      27       File too large
00349     ENOSPC                     28       No space left on device
00350     ESPIPE                     29       Illegal seek
00351     EROFS                      30       Read-only file system
00352     EMLINK                     31       Too many links
00353     EPIPE                      32       Broken pipe
00354     EDOM                       33       Math argument out of domain of func
00355     ERANGE                     34       Math result not representable
00356     EDEADLK                    35       Resource deadlock would occur
00357     ENAMETOOLONG               36       File name too long
00358     ENOLCK                     37       No record locks available
00359     ENOSYS                     38       Function not implemented
00360     ENOTEMPTY                  39       Directory not empty
00361     ELOOP                      40       Too many symbolic links encountered
00362     EWOULDBLOCK                EAGAIN   Operation would block
00363     ENOMSG                     42       No message of desired type
00364     EIDRM                      43       Identifier removed
00365     ECHRNG                     44       Channel number out of range
00366     EL2NSYNC                   45       Level 2 not synchronized
00367     EL3HLT                     46       Level 3 halted
00368     EL3RST                     47       Level 3 reset
00369     ELNRNG                     48       Link number out of range
00370     EUNATCH                    49       Protocol driver not attached
00371     ENOCSI                     50       No CSI structure available
00372     EL2HLT                     51       Level 2 halted
00373     EBADE                      52       Invalid exchange
00374     EBADR                      53       Invalid request descriptor
00375     EXFULL                     54       Exchange full
00376     ENOANO                     55       No anode
00377     EBADRQC                    56       Invalid request code
00378     EBADSLT                    57       Invalid slot
00379     EDEADLOCK                  EDEADLK  Resource deadlock would occur
00380     EBFONT                     59       Bad font file format
00381     ENOSTR                     60       Device not a stream
00382     ENODATA                    61       No data available
00383     ETIME                      62       Timer expired
00384     ENOSR                      63       Out of streams resources
00385     ENONET                     64       Machine is not on the network
00386     ENOPKG                     65       Package not installed
00387     EREMOTE                    66       Object is remote
00388     ENOLINK                    67       Link has been severed
00389     EADV                       68       Advertise error
00390     ESRMNT                     69       Srmount error
00391     ECOMM                      70       Communication error on send
00392     EPROTO                     71       Protocol error
00393     EMULTIHOP                  72       Multihop attempted
00394     EDOTDOT                    73       RFS specific error
00395     EBADMSG                    74       Not a data message
00396     EOVERFLOW                  75       Value too large for defined data type
00397     ENOTUNIQ                   76       Name not unique on network
00398     EBADFD                     77       File descriptor in bad state
00399     EREMCHG                    78       Remote address changed
00400     ELIBACC                    79       Can not access a needed shared library
00401     ELIBBAD                    80       Accessing a corrupted shared library
00402     ELIBSCN                    81       .lib section in a.out corrupted
00403     ELIBMAX                    82       Attempting to link in too many shared libraries
00404     ELIBEXEC                   83       Cannot exec a shared library directly
00405     EILSEQ                     84       Illegal byte sequence
00406     ERESTART                   85       Interrupted system call should be restarted
00407     ESTRPIPE                   86       Streams pipe error
00408     EUSERS                     87       Too many users
00409     ENOTSOCK                   88       Socket operation on non-socket
00410     EDESTADDRREQ               89       Destination address required
00411     EMSGSIZE                   90       Message too long
00412     EPROTOTYPE                 91       Protocol wrong type for socket
00413     ENOPROTOOPT                92       Protocol not available
00414     EPROTONOSUPPORT            93       Protocol not supported
00415     ESOCKTNOSUPPORT            94       Socket type not supported
00416     EOPNOTSUPP                 95       Operation not supported on transport endpoint
00417     EPFNOSUPPORT               96       Protocol family not supported
00418     EAFNOSUPPORT               97       Address family not supported by protocol
00419     EADDRINUSE                 98       Address already in use
00420     EADDRNOTAVAIL              99       Cannot assign requested address
00421     ENETDOWN                   100      Network is down
00422     ENETUNREACH                101      Network is unreachable
00423     ENETRESET                  102      Network dropped connection because of reset
00424     ECONNABORTED               103      Software caused connection abort
00425     ECONNRESET                 104      Connection reset by peer
00426     ENOBUFS                    105      No buffer space available
00427     EISCONN                    106      Transport endpoint is already connected
00428     ENOTCONN                   107      Transport endpoint is not connected
00429     ESHUTDOWN                  108      Cannot send after transport endpoint shutdown
00430     ETOOMANYREFS               109      Too many references: cannot splice
00431     ETIMEDOUT                  110      Connection timed out
00432     ECONNREFUSED               111      Connection refused
00433     EHOSTDOWN                  112      Host is down
00434     EHOSTUNREACH               113      No route to host
00435     EALREADY                   114      Operation already in progress
00436     EINPROGRESS                115      Operation now in progress
00437     ESTALE                     116      Stale NFS file handle
00438     EUCLEAN                    117      Structure needs cleaning
00439     ENOTNAM                    118      Not a XENIX named type file
00440     ENAVAIL                    119      No XENIX semaphores available
00441     EISNAM                     120      Is a named type file
00442     EREMOTEIO                  121      Remote I/O error
00443     EDQUOT                     122      Quota exceeded
00444     ENOMEDIUM                  123      No medium found
00445     EMEDIUMTYPE                124      Wrong medium type
00446     ECANCELED                  125      Operation Canceled
00447     ENOKEY                     126      Required key not available
00448     EKEYEXPIRED                127      Key has expired
00449     EKEYREVOKED                128      Key has been revoked
00450     EKEYREJECTED               129      Key was rejected by service
00451     EOWNERDEAD                 130      Owner died
00452     ENOTRECOVERABLE            131      State not recoverable
00453     \endverbatim
00454  *
00455  *  @note
00456  *  MbedOS System Error codes are defined using the macro MBED_DEFINE_SYSTEM_ERROR\n
00457  *  For example MBED_DEFINE_SYSTEM_ERROR( INVALID_ARGUMENT ,1 ) macro defines the following values:\n
00458  *      ERROR_CODE_INVALID_ARGUMENT = MBED_SYSTEM_ERROR_BASE+1\n
00459  *      ERROR_INVALID_ARGUMENT = MAKE_MBED_ERROR(ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, ERROR_CODE_INVALID_ARGUMENT)\n
00460  *  Its effectively equivalent to:\n
00461  *      ERROR_CODE_INVALID_ARGUMENT = 1\n
00462  *      ERROR_INVALID_ARGUMENT = 0x80FF0001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN)
00463  *  New System Error codes should be defined using MBED_DEFINE_SYSTEM_ERROR macro and must have an unique error code value\n
00464  *  passed as the second argument in the MBED_DEFINE_SYSTEM_ERROR macro.\n\n
00465  *  Below are the Mbed System error codes and the description:
00466  *  \verbatim
00467     UNKNOWN                    256      Unknown error
00468     INVALID_ARGUMENT           257      Invalid Argument
00469     INVALID_DATA               258      Invalid data
00470     INVALID_FORMAT             259      Invalid format
00471     INVALID_INDEX              260      Invalid Index
00472     INVALID_SIZE               261      Inavlid Size
00473     INVALID_OPERATION          262      Invalid Operation
00474     NOT_FOUND                  263      Not Found
00475     ACCESS_DENIED              264      Access Denied
00476     NOT_SUPPORTED              265      Not supported
00477     BUFFER_FULL                266      Buffer Full
00478     MEDIA_FULL                 267      Media/Disk Full
00479     ALREADY_IN_USE             268      Already in use
00480     TIMEOUT                    269      Timeout error
00481     NOT_READY                  270      Not Ready
00482     FAILED_OPERATION           271      Requested Operation failed
00483     OPERATION_PROHIBITED       272      Operation prohibited
00484     OPERATION_ABORTED          273      Operation failed
00485     WRITE_PROTECTED            274      Attempt to write to write-protected resource
00486     NO_RESPONSE                275      No response
00487     SEMAPHORE_LOCK_FAILED      276      Sempahore lock failed
00488     MUTEX_LOCK_FAILED          277      Mutex lock failed
00489     SEMAPHORE_UNLOCK_FAILED    278      Sempahore unlock failed
00490     MUTEX_UNLOCK_FAILED        279      Mutex unlock failed
00491     CRC_ERROR                  280      CRC error or mismatch
00492     OPEN_FAILED                281      Open failed
00493     CLOSE_FAILED               282      Close failed
00494     READ_FAILED                283      Read failed
00495     WRITE_FAILED               284      Write failed
00496     INITIALIZATION_FAILED      285      Initialization failed
00497     BOOT_FAILURE               286      Boot failure
00498     OUT_OF_MEMORY              287      Out of memory
00499     OUT_OF_RESOURCES           288      Out of resources
00500     ALLOC_FAILED               289      Alloc failed
00501     FREE_FAILED                290      Free failed
00502     OVERFLOW                   291      Overflow error
00503     UNDERFLOW                  292      Underflow error
00504     STACK_OVERFLOW             293      Stack overflow error
00505     ISR_QUEUE_OVERFLOW         294      ISR queue overflow
00506     TIMER_QUEUE_OVERFLOW       295      Timer Queue overflow
00507     CLIB_SPACE_UNAVAILABLE     296      Standard library error - Space unavailable
00508     CLIB_EXCEPTION             297      Standard library error - Exception
00509     CLIB_MUTEX_INIT_FAILURE    298      Standard library error - Mutex Init failure
00510     CREATE_FAILED              299      Create failed
00511     DELETE_FAILED              300      Delete failed
00512     THREAD_CREATE_FAILED       301      Thread Create failed
00513     THREAD_DELETE_FAILED       302      Thread Delete failed
00514     PROHIBITED_IN_ISR_CONTEXT  303      Operation Prohibited in ISR context
00515     PINMAP_INVALID             304      Pinmap Invalid
00516     RTOS_EVENT                 305      Unknown Rtos Error
00517     RTOS_THREAD_EVENT          306      Rtos Thread Error
00518     RTOS_MUTEX_EVENT           307      Rtos Mutex Error
00519     RTOS_SEMAPHORE_EVENT       308      Rtos Semaphore Error
00520     RTOS_MEMORY_POOL_EVENT     309      Rtos Memory Pool Error
00521     RTOS_TIMER_EVENT           310      Rtos Timer Error
00522     RTOS_EVENT_FLAGS_EVENT     311      Rtos Event flags Error
00523     RTOS_MESSAGE_QUEUE_EVENT   312      Rtos Message queue Error
00524     DEVICE_BUSY                313      Device Busy
00525     CONFIG_UNSUPPORTED         314      Configuration not supported
00526     CONFIG_MISMATCH            315      Configuration mismatch
00527     ALREADY_INITIALIZED        316      Already initialzied
00528     HARDFAULT_EXCEPTION        317      HardFault exception
00529     MEMMANAGE_EXCEPTION        318      MemManage exception
00530     BUSFAULT_EXCEPTION         319      BusFault exception
00531     USAGEFAULT_EXCEPTION       320      UsageFault exception
00532     \endverbatim
00533  *
00534  *  @note
00535  *  Custom Error codes can be defined using the macro DEFINE_CUSTOM_ERROR\n
00536  *  This is mainly meant to capture non-generic error codes specific to a device.
00537  *  For example DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR ,1 ) macro defines the following values:\n
00538  *      ERROR_CODE_MY_CUSTOM_ERROR = MBED_CUSTOM_ERROR_BASE+1\n
00539  *      ERROR_MY_CUSTOM_ERROR = MAKE_MBED_ERROR(ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, ERROR_CODE_MY_CUSTOM_ERROR)\n
00540  *  Its effectively equivalent to:\n
00541  *      ERROR_CODE_MY_CUSTOM_ERROR = 4097\n
00542  *      ERROR_MY_CUSTOM_ERROR = 0xA0FF1001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN) \n\n
00543  *
00544  *  @note
00545  *  **Using error codes:** \n
00546  *  Posix error codes may be used in modules/functions currently using Posix error codes and switching them to Mbed-OS error codes
00547  *  may cause interoperability issues. For example, some of the filesystem, network stack implementations may need to use
00548  *  Posix error codes in order to keep them compatible with other modules interfacing with them, and may continue to use Posix error codes.
00549  *
00550  *  In all other cases, like for any native development of Mbed-OS modules Mbed-OS error codes should be used.
00551  *  This makes it easy to use Mbed-OS error reporting/logging infrastructure and makes debugging error scenarios
00552  *  much more efficient.
00553  *
00554  *  @note
00555  *  **Searching for error codes in mbed-os source tree:** \n
00556  *  If you get an error report as below which you want to search for in mbed-os source tree, first take note of "Error Code" number. \n
00557  *  For example, the below error report has an error code of \b 259. Find the error name associated with the error code and in this case its \b INVALID_FORMAT. \n
00558  *  Use that error name(\b INVALID_FORMAT) to search the source tree for code locations setting that specific error code. \n
00559  *  If the Error module reported is not 255(which indicates unknown module), you can also use that to narrow down to the specific component reporting the error.
00560  *  See mbed_module_type_t enum above for module mapping. \n
00561  *
00562  *  \verbatim
00563     ++ MbedOS Error Info ++
00564     Error Status: 0x80040103
00565     Error Code: 259
00566     Error Module: 04
00567     Error Message: HAL Module error
00568     Error Location: 0x000067C7
00569     Error Value: 0x00005566
00570     Current Thread: Id: 0x200024A8 EntryFn: 0x0000FB0D StackSize: 0x00001000 StackMem: 0x200014A8 SP: 0x2002FFD8
00571     -- MbedOS Error Info --
00572     \endverbatim
00573  */
00574 
00575 typedef enum _mbed_error_code {
00576     //Below are POSIX ERROR CODE definitions, which starts at MBED_POSIX_ERROR_BASE(=0)
00577     //POSIX ERROR CODE definitions starts at offset 0(MBED_POSIX_ERROR_BASE) to align them with actual Posix Error Code
00578     //defintions in mbed_retarget.h
00579     //                  Error Name                                    Error Code
00580     MBED_DEFINE_POSIX_ERROR(EPERM, EPERM),                              /* 1       Operation not permitted */
00581     MBED_DEFINE_POSIX_ERROR(ENOENT, ENOENT),                            /* 2       No such file or directory */
00582     MBED_DEFINE_POSIX_ERROR(ESRCH, ESRCH),                              /* 3       No such process */
00583     MBED_DEFINE_POSIX_ERROR(EINTR, EINTR),                              /* 4       Interrupted system call */
00584     MBED_DEFINE_POSIX_ERROR(EIO, EIO),                                  /* 5       I/O error */
00585     MBED_DEFINE_POSIX_ERROR(ENXIO, ENXIO),                              /* 6       No such device or address */
00586     MBED_DEFINE_POSIX_ERROR(E2BIG, E2BIG),                              /* 7       Argument list too long */
00587     MBED_DEFINE_POSIX_ERROR(ENOEXEC, ENOEXEC),                          /* 8       Exec format error */
00588     MBED_DEFINE_POSIX_ERROR(EBADF, EBADF),                              /* 9       Bad file number */
00589     MBED_DEFINE_POSIX_ERROR(ECHILD, ECHILD),                            /* 10      No child processes */
00590     MBED_DEFINE_POSIX_ERROR(EAGAIN, EAGAIN),                            /* 11      Try again */
00591     MBED_DEFINE_POSIX_ERROR(ENOMEM, ENOMEM),                            /* 12      Out of memory */
00592     MBED_DEFINE_POSIX_ERROR(EACCES, EACCES),                            /* 13      Permission denied */
00593     MBED_DEFINE_POSIX_ERROR(EFAULT, EFAULT),                            /* 14      Bad address */
00594     MBED_DEFINE_POSIX_ERROR(ENOTBLK, ENOTBLK),                          /* 15      Block device required */
00595     MBED_DEFINE_POSIX_ERROR(EBUSY, EBUSY),                              /* 16      Device or resource busy */
00596     MBED_DEFINE_POSIX_ERROR(EEXIST, EEXIST),                            /* 17      File exists */
00597     MBED_DEFINE_POSIX_ERROR(EXDEV, EXDEV),                              /* 18      Cross-device link */
00598     MBED_DEFINE_POSIX_ERROR(ENODEV, ENODEV),                            /* 19      No such device */
00599     MBED_DEFINE_POSIX_ERROR(ENOTDIR, ENOTDIR),                          /* 20      Not a directory */
00600     MBED_DEFINE_POSIX_ERROR(EISDIR, EISDIR),                            /* 21      Is a directory */
00601     MBED_DEFINE_POSIX_ERROR(EINVAL, EINVAL),                            /* 22      Invalid argument */
00602     MBED_DEFINE_POSIX_ERROR(ENFILE, ENFILE),                            /* 23      File table overflow */
00603     MBED_DEFINE_POSIX_ERROR(EMFILE, EMFILE),                            /* 24      Too many open files */
00604     MBED_DEFINE_POSIX_ERROR(ENOTTY, ENOTTY),                            /* 25      Not a typewriter */
00605     MBED_DEFINE_POSIX_ERROR(ETXTBSY, ETXTBSY),                          /* 26      Text file busy */
00606     MBED_DEFINE_POSIX_ERROR(EFBIG, EFBIG),                              /* 27      File too large */
00607     MBED_DEFINE_POSIX_ERROR(ENOSPC, ENOSPC),                            /* 28      No space left on device */
00608     MBED_DEFINE_POSIX_ERROR(ESPIPE, ESPIPE),                            /* 29      Illegal seek */
00609     MBED_DEFINE_POSIX_ERROR(EROFS, EROFS),                              /* 30      Read-only file system */
00610     MBED_DEFINE_POSIX_ERROR(EMLINK, EMLINK),                            /* 31      Too many links */
00611     MBED_DEFINE_POSIX_ERROR(EPIPE, EPIPE),                              /* 32      Broken pipe */
00612     MBED_DEFINE_POSIX_ERROR(EDOM, EDOM),                                /* 33      Math argument out of domain of func */
00613     MBED_DEFINE_POSIX_ERROR(ERANGE, ERANGE),                            /* 34      Math result not representable */
00614     MBED_DEFINE_POSIX_ERROR(EDEADLK, EDEADLK),                          /* 35      Resource deadlock would occur */
00615     MBED_DEFINE_POSIX_ERROR(ENAMETOOLONG, ENAMETOOLONG),                /* 36      File name too long */
00616     MBED_DEFINE_POSIX_ERROR(ENOLCK, ENOLCK),                            /* 37      No record locks available */
00617     MBED_DEFINE_POSIX_ERROR(ENOSYS, ENOSYS),                            /* 38      Function not implemented */
00618     MBED_DEFINE_POSIX_ERROR(ENOTEMPTY, ENOTEMPTY),                      /* 39      Directory not empty */
00619     MBED_DEFINE_POSIX_ERROR(ELOOP, ELOOP),                              /* 40      Too many symbolic links encountered */
00620     MBED_DEFINE_POSIX_ERROR(EWOULDBLOCK, EAGAIN),                       /* EAGAIN  Operation would block */
00621     MBED_DEFINE_POSIX_ERROR(ENOMSG, ENOMSG),                            /* 42      No message of desired type */
00622     MBED_DEFINE_POSIX_ERROR(EIDRM, EIDRM),                              /* 43      Identifier removed */
00623     MBED_DEFINE_POSIX_ERROR(ECHRNG, ECHRNG),                            /* 44      Channel number out of range */
00624     MBED_DEFINE_POSIX_ERROR(EL2NSYNC, EL2NSYNC),                        /* 45      Level 2 not synchronized */
00625     MBED_DEFINE_POSIX_ERROR(EL3HLT, EL3HLT),                            /* 46      Level 3 halted */
00626     MBED_DEFINE_POSIX_ERROR(EL3RST, EL3RST),                            /* 47      Level 3 reset */
00627     MBED_DEFINE_POSIX_ERROR(ELNRNG, ELNRNG),                            /* 48      Link number out of range */
00628     MBED_DEFINE_POSIX_ERROR(EUNATCH, EUNATCH),                          /* 49      Protocol driver not attached */
00629     MBED_DEFINE_POSIX_ERROR(ENOCSI, ENOCSI),                            /* 50      No CSI structure available */
00630     MBED_DEFINE_POSIX_ERROR(EL2HLT, EL2HLT),                            /* 51      Level 2 halted */
00631     MBED_DEFINE_POSIX_ERROR(EBADE, EBADE),                              /* 52      Invalid exchange */
00632     MBED_DEFINE_POSIX_ERROR(EBADR, EBADR),                              /* 53      Invalid request descriptor */
00633     MBED_DEFINE_POSIX_ERROR(EXFULL, EXFULL),                            /* 54      Exchange full */
00634     MBED_DEFINE_POSIX_ERROR(ENOANO, ENOANO),                            /* 55      No anode */
00635     MBED_DEFINE_POSIX_ERROR(EBADRQC, EBADRQC),                          /* 56      Invalid request code */
00636     MBED_DEFINE_POSIX_ERROR(EBADSLT, EBADSLT),                          /* 57      Invalid slot */
00637     MBED_DEFINE_POSIX_ERROR(EDEADLOCK, EDEADLK),                        /* EDEADLK Resource deadlock would occur */
00638     MBED_DEFINE_POSIX_ERROR(EBFONT, EBFONT),                            /* 59      Bad font file format */
00639     MBED_DEFINE_POSIX_ERROR(ENOSTR, ENOSTR),                            /* 60      Device not a stream */
00640     MBED_DEFINE_POSIX_ERROR(ENODATA, ENODATA),                          /* 61      No data available */
00641     MBED_DEFINE_POSIX_ERROR(ETIME, ETIME),                              /* 62      Timer expired */
00642     MBED_DEFINE_POSIX_ERROR(ENOSR, ENOSR),                              /* 63      Out of streams resources */
00643     MBED_DEFINE_POSIX_ERROR(ENONET, ENONET),                            /* 64      Machine is not on the network */
00644     MBED_DEFINE_POSIX_ERROR(ENOPKG, ENOPKG),                            /* 65      Package not installed */
00645     MBED_DEFINE_POSIX_ERROR(EREMOTE, EREMOTE),                          /* 66      Object is remote */
00646     MBED_DEFINE_POSIX_ERROR(ENOLINK, ENOLINK),                          /* 67      Link has been severed */
00647     MBED_DEFINE_POSIX_ERROR(EADV, EADV),                                /* 68      Advertise error */
00648     MBED_DEFINE_POSIX_ERROR(ESRMNT, ESRMNT),                            /* 69      Srmount error */
00649     MBED_DEFINE_POSIX_ERROR(ECOMM, ECOMM),                              /* 70      Communication error on send */
00650     MBED_DEFINE_POSIX_ERROR(EPROTO, EPROTO),                            /* 71      Protocol error */
00651     MBED_DEFINE_POSIX_ERROR(EMULTIHOP, EMULTIHOP),                      /* 72      Multihop attempted */
00652     MBED_DEFINE_POSIX_ERROR(EDOTDOT, EDOTDOT),                          /* 73      RFS specific error */
00653     MBED_DEFINE_POSIX_ERROR(EBADMSG, EBADMSG),                          /* 74      Not a data message */
00654     MBED_DEFINE_POSIX_ERROR(EOVERFLOW, EOVERFLOW),                      /* 75      Value too large for defined data type */
00655     MBED_DEFINE_POSIX_ERROR(ENOTUNIQ, ENOTUNIQ),                        /* 76      Name not unique on network */
00656     MBED_DEFINE_POSIX_ERROR(EBADFD, EBADFD),                            /* 77      File descriptor in bad state */
00657     MBED_DEFINE_POSIX_ERROR(EREMCHG, EREMCHG),                          /* 78      Remote address changed */
00658     MBED_DEFINE_POSIX_ERROR(ELIBACC, ELIBACC),                          /* 79      Can not access a needed shared library */
00659     MBED_DEFINE_POSIX_ERROR(ELIBBAD, ELIBBAD),                          /* 80      Accessing a corrupted shared library */
00660     MBED_DEFINE_POSIX_ERROR(ELIBSCN, ELIBSCN),                          /* 81      .lib section in a.out corrupted */
00661     MBED_DEFINE_POSIX_ERROR(ELIBMAX, ELIBMAX),                          /* 82      Attempting to link in too many shared libraries */
00662     MBED_DEFINE_POSIX_ERROR(ELIBEXEC, ELIBEXEC),                        /* 83      Cannot exec a shared library directly */
00663     MBED_DEFINE_POSIX_ERROR(EILSEQ, EILSEQ),                            /* 84      Illegal byte sequence */
00664     MBED_DEFINE_POSIX_ERROR(ERESTART, ERESTART),                        /* 85      Interrupted system call should be restarted */
00665     MBED_DEFINE_POSIX_ERROR(ESTRPIPE, ESTRPIPE),                        /* 86      Streams pipe error */
00666     MBED_DEFINE_POSIX_ERROR(EUSERS, EUSERS),                            /* 87      Too many users */
00667     MBED_DEFINE_POSIX_ERROR(ENOTSOCK, ENOTSOCK),                        /* 88      Socket operation on non-socket */
00668     MBED_DEFINE_POSIX_ERROR(EDESTADDRREQ, EDESTADDRREQ),                /* 89      Destination address required */
00669     MBED_DEFINE_POSIX_ERROR(EMSGSIZE, EMSGSIZE),                        /* 90      Message too long */
00670     MBED_DEFINE_POSIX_ERROR(EPROTOTYPE, EPROTOTYPE),                    /* 91      Protocol wrong type for socket */
00671     MBED_DEFINE_POSIX_ERROR(ENOPROTOOPT, ENOPROTOOPT),                  /* 92      Protocol not available */
00672     MBED_DEFINE_POSIX_ERROR(EPROTONOSUPPORT, EPROTONOSUPPORT),          /* 93      Protocol not supported */
00673     MBED_DEFINE_POSIX_ERROR(ESOCKTNOSUPPORT, ESOCKTNOSUPPORT),          /* 94      Socket type not supported */
00674     MBED_DEFINE_POSIX_ERROR(EOPNOTSUPP, EOPNOTSUPP),                    /* 95      Operation not supported on transport endpoint */
00675     MBED_DEFINE_POSIX_ERROR(EPFNOSUPPORT, EPFNOSUPPORT),                /* 96      Protocol family not supported */
00676     MBED_DEFINE_POSIX_ERROR(EAFNOSUPPORT, EAFNOSUPPORT),                /* 97      Address family not supported by protocol */
00677     MBED_DEFINE_POSIX_ERROR(EADDRINUSE, EADDRINUSE),                    /* 98      Address already in use */
00678     MBED_DEFINE_POSIX_ERROR(EADDRNOTAVAIL, EADDRNOTAVAIL),              /* 99      Cannot assign requested address */
00679     MBED_DEFINE_POSIX_ERROR(ENETDOWN, ENETDOWN),                        /* 100     Network is down */
00680     MBED_DEFINE_POSIX_ERROR(ENETUNREACH, ENETUNREACH),                  /* 101     Network is unreachable */
00681     MBED_DEFINE_POSIX_ERROR(ENETRESET, ENETRESET),                      /* 102     Network dropped connection because of reset */
00682     MBED_DEFINE_POSIX_ERROR(ECONNABORTED, ECONNABORTED),                /* 103     Software caused connection abort */
00683     MBED_DEFINE_POSIX_ERROR(ECONNRESET, ECONNRESET),                    /* 104     Connection reset by peer */
00684     MBED_DEFINE_POSIX_ERROR(ENOBUFS, ENOBUFS),                          /* 105     No buffer space available */
00685     MBED_DEFINE_POSIX_ERROR(EISCONN, EISCONN),                          /* 106     Transport endpoint is already connected */
00686     MBED_DEFINE_POSIX_ERROR(ENOTCONN, ENOTCONN),                        /* 107     Transport endpoint is not connected */
00687     MBED_DEFINE_POSIX_ERROR(ESHUTDOWN, ESHUTDOWN),                      /* 108     Cannot send after transport endpoint shutdown */
00688     MBED_DEFINE_POSIX_ERROR(ETOOMANYREFS, ETOOMANYREFS),                /* 109     Too many references: cannot splice */
00689     MBED_DEFINE_POSIX_ERROR(ETIMEDOUT, ETIMEDOUT),                      /* 110     Connection timed out */
00690     MBED_DEFINE_POSIX_ERROR(ECONNREFUSED, ECONNREFUSED),                /* 111     Connection refused */
00691     MBED_DEFINE_POSIX_ERROR(EHOSTDOWN, EHOSTDOWN),                      /* 112     Host is down */
00692     MBED_DEFINE_POSIX_ERROR(EHOSTUNREACH, EHOSTUNREACH),                /* 113     No route to host */
00693     MBED_DEFINE_POSIX_ERROR(EALREADY, EALREADY),                        /* 114     Operation already in progress */
00694     MBED_DEFINE_POSIX_ERROR(EINPROGRESS, EINPROGRESS),                  /* 115     Operation now in progress */
00695     MBED_DEFINE_POSIX_ERROR(ESTALE, ESTALE),                            /* 116     Stale NFS file handle */
00696     MBED_DEFINE_POSIX_ERROR(EUCLEAN, EUCLEAN),                          /* 117     Structure needs cleaning */
00697     MBED_DEFINE_POSIX_ERROR(ENOTNAM, ENOTNAM),                          /* 118     Not a XENIX named type file */
00698     MBED_DEFINE_POSIX_ERROR(ENAVAIL, ENAVAIL),                          /* 119     No XENIX semaphores available */
00699     MBED_DEFINE_POSIX_ERROR(EISNAM, EISNAM),                            /* 120     Is a named type file */
00700     MBED_DEFINE_POSIX_ERROR(EREMOTEIO, EREMOTEIO),                      /* 121     Remote I/O error */
00701     MBED_DEFINE_POSIX_ERROR(EDQUOT, EDQUOT),                            /* 122     Quota exceeded */
00702     MBED_DEFINE_POSIX_ERROR(ENOMEDIUM, ENOMEDIUM),                      /* 123     No medium found */
00703     MBED_DEFINE_POSIX_ERROR(EMEDIUMTYPE, EMEDIUMTYPE),                  /* 124     Wrong medium type */
00704     MBED_DEFINE_POSIX_ERROR(ECANCELED, ECANCELED),                      /* 125     Operation Canceled */
00705     MBED_DEFINE_POSIX_ERROR(ENOKEY, ENOKEY),                            /* 126     Required key not available */
00706     MBED_DEFINE_POSIX_ERROR(EKEYEXPIRED, EKEYEXPIRED),                  /* 127     Key has expired */
00707     MBED_DEFINE_POSIX_ERROR(EKEYREVOKED, EKEYREVOKED),                  /* 128     Key has been revoked */
00708     MBED_DEFINE_POSIX_ERROR(EKEYREJECTED, EKEYREJECTED),                /* 129     Key was rejected by service */
00709     MBED_DEFINE_POSIX_ERROR(EOWNERDEAD, EOWNERDEAD),                    /* 130     Owner died */
00710     MBED_DEFINE_POSIX_ERROR(ENOTRECOVERABLE, ENOTRECOVERABLE),          /* 131     State not recoverable */
00711 
00712     //Below are MBED SYSTEM ERROR CODE definitions
00713     //MBED SYSTEM ERROR CODE definitions starts at offset MBED_SYSTEM_ERROR_BASE, see above.
00714     //                   Error Name                 Error Offset   Error Code
00715     MBED_DEFINE_SYSTEM_ERROR(UNKNOWN, 0),                               /* 256      Unknown error */
00716     MBED_DEFINE_SYSTEM_ERROR(INVALID_ARGUMENT, 1),                      /* 257      Invalid Argument */
00717     MBED_DEFINE_SYSTEM_ERROR(INVALID_DATA_DETECTED, 2),                 /* 258      Invalid data detected */
00718     MBED_DEFINE_SYSTEM_ERROR(INVALID_FORMAT, 3),                        /* 259      Invalid format */
00719     MBED_DEFINE_SYSTEM_ERROR(INVALID_INDEX, 4),                         /* 260      Invalid Index */
00720     MBED_DEFINE_SYSTEM_ERROR(INVALID_SIZE, 5),                          /* 261      Inavlid Size */
00721     MBED_DEFINE_SYSTEM_ERROR(INVALID_OPERATION, 6),                     /* 262      Invalid Operation */
00722     MBED_DEFINE_SYSTEM_ERROR(ITEM_NOT_FOUND, 7),                        /* 263      Item Not Found */
00723     MBED_DEFINE_SYSTEM_ERROR(ACCESS_DENIED, 8),                         /* 264      Access Denied */
00724     MBED_DEFINE_SYSTEM_ERROR(UNSUPPORTED, 9),                           /* 265      Unsupported */
00725     MBED_DEFINE_SYSTEM_ERROR(BUFFER_FULL, 10),                          /* 266      Buffer Full */
00726     MBED_DEFINE_SYSTEM_ERROR(MEDIA_FULL, 11),                           /* 267      Media/Disk Full */
00727     MBED_DEFINE_SYSTEM_ERROR(ALREADY_IN_USE, 12),                       /* 268      Already in use */
00728     MBED_DEFINE_SYSTEM_ERROR(TIME_OUT, 13),                             /* 269      Timeout error */
00729     MBED_DEFINE_SYSTEM_ERROR(NOT_READY, 14),                            /* 270      Not Ready */
00730     MBED_DEFINE_SYSTEM_ERROR(FAILED_OPERATION, 15),                     /* 271      Requested Operation failed */
00731     MBED_DEFINE_SYSTEM_ERROR(OPERATION_PROHIBITED, 16),                 /* 272      Operation prohibited */
00732     MBED_DEFINE_SYSTEM_ERROR(OPERATION_ABORTED, 17),                    /* 273      Operation failed */
00733     MBED_DEFINE_SYSTEM_ERROR(WRITE_PROTECTED, 18),                      /* 274      Attempt to write to write-protected resource */
00734     MBED_DEFINE_SYSTEM_ERROR(NO_RESPONSE, 19),                          /* 275      No response */
00735     MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_LOCK_FAILED, 20),                /* 276      Sempahore lock failed */
00736     MBED_DEFINE_SYSTEM_ERROR(MUTEX_LOCK_FAILED, 21),                    /* 277      Mutex lock failed */
00737     MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_UNLOCK_FAILED, 22),              /* 278      Sempahore unlock failed */
00738     MBED_DEFINE_SYSTEM_ERROR(MUTEX_UNLOCK_FAILED, 23),                  /* 279      Mutex unlock failed */
00739     MBED_DEFINE_SYSTEM_ERROR(CRC_ERROR, 24),                            /* 280      CRC error or mismatch */
00740     MBED_DEFINE_SYSTEM_ERROR(OPEN_FAILED, 25),                          /* 281      Open failed */
00741     MBED_DEFINE_SYSTEM_ERROR(CLOSE_FAILED, 26),                         /* 282      Close failed */
00742     MBED_DEFINE_SYSTEM_ERROR(READ_FAILED, 27),                          /* 283      Read failed */
00743     MBED_DEFINE_SYSTEM_ERROR(WRITE_FAILED, 28),                         /* 284      Write failed */
00744     MBED_DEFINE_SYSTEM_ERROR(INITIALIZATION_FAILED, 29),                /* 285      Initialization failed */
00745     MBED_DEFINE_SYSTEM_ERROR(BOOT_FAILURE, 30),                         /* 286      Boot failure */
00746     MBED_DEFINE_SYSTEM_ERROR(OUT_OF_MEMORY, 31),                        /* 287      Out of memory */
00747     MBED_DEFINE_SYSTEM_ERROR(OUT_OF_RESOURCES, 32),                     /* 288      Out of resources */
00748     MBED_DEFINE_SYSTEM_ERROR(ALLOC_FAILED, 33),                         /* 289      Alloc failed */
00749     MBED_DEFINE_SYSTEM_ERROR(FREE_FAILED, 34),                          /* 290      Free failed */
00750     MBED_DEFINE_SYSTEM_ERROR(OVERFLOW, 35),                             /* 291      Overflow error */
00751     MBED_DEFINE_SYSTEM_ERROR(UNDERFLOW, 36),                            /* 292      Underflow error */
00752     MBED_DEFINE_SYSTEM_ERROR(STACK_OVERFLOW, 37),                       /* 293      Stack overflow error */
00753     MBED_DEFINE_SYSTEM_ERROR(ISR_QUEUE_OVERFLOW, 38),                   /* 294      ISR queue overflow */
00754     MBED_DEFINE_SYSTEM_ERROR(TIMER_QUEUE_OVERFLOW, 39),                 /* 295      Timer Queue overflow */
00755     MBED_DEFINE_SYSTEM_ERROR(CLIB_SPACE_UNAVAILABLE, 40),               /* 296      Standard library error - Space unavailable */
00756     MBED_DEFINE_SYSTEM_ERROR(CLIB_EXCEPTION, 41),                       /* 297      Standard library error - Exception */
00757     MBED_DEFINE_SYSTEM_ERROR(CLIB_MUTEX_INIT_FAILURE, 42),              /* 298      Standard library error - Mutex Init failure */
00758     MBED_DEFINE_SYSTEM_ERROR(CREATE_FAILED, 43),                        /* 299      Create failed */
00759     MBED_DEFINE_SYSTEM_ERROR(DELETE_FAILED, 44),                        /* 300      Delete failed */
00760     MBED_DEFINE_SYSTEM_ERROR(THREAD_CREATE_FAILED, 45),                 /* 301      Thread Create failed */
00761     MBED_DEFINE_SYSTEM_ERROR(THREAD_DELETE_FAILED, 46),                 /* 302      Thread Delete failed */
00762     MBED_DEFINE_SYSTEM_ERROR(PROHIBITED_IN_ISR_CONTEXT, 47),            /* 303      Operation Prohibited in ISR context */
00763     MBED_DEFINE_SYSTEM_ERROR(PINMAP_INVALID, 48),                       /* 304      Pinmap Invalid */
00764     MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT, 49),                           /* 305      Unknown Rtos Error */
00765     MBED_DEFINE_SYSTEM_ERROR(RTOS_THREAD_EVENT, 50),                    /* 306      Rtos Thread Error */
00766     MBED_DEFINE_SYSTEM_ERROR(RTOS_MUTEX_EVENT, 51),                     /* 307      Rtos Mutex Error */
00767     MBED_DEFINE_SYSTEM_ERROR(RTOS_SEMAPHORE_EVENT, 52),                 /* 308      Rtos Semaphore Error */
00768     MBED_DEFINE_SYSTEM_ERROR(RTOS_MEMORY_POOL_EVENT, 53),               /* 309      Rtos Memory Pool Error */
00769     MBED_DEFINE_SYSTEM_ERROR(RTOS_TIMER_EVENT, 54),                     /* 310      Rtos Timer Error */
00770     MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT_FLAGS_EVENT, 55),               /* 311      Rtos Event flags Error */
00771     MBED_DEFINE_SYSTEM_ERROR(RTOS_MESSAGE_QUEUE_EVENT, 56),             /* 312      Rtos Message queue Error */
00772     MBED_DEFINE_SYSTEM_ERROR(DEVICE_BUSY, 57),                          /* 313      Device Busy */
00773     MBED_DEFINE_SYSTEM_ERROR(CONFIG_UNSUPPORTED, 58),                   /* 314      Configuration not supported */
00774     MBED_DEFINE_SYSTEM_ERROR(CONFIG_MISMATCH, 59),                      /* 315      Configuration mismatch */
00775     MBED_DEFINE_SYSTEM_ERROR(ALREADY_INITIALIZED, 60),                  /* 316      Already initialzied */
00776     MBED_DEFINE_SYSTEM_ERROR(HARDFAULT_EXCEPTION, 61),                  /* 317      HardFault exception */
00777     MBED_DEFINE_SYSTEM_ERROR(MEMMANAGE_EXCEPTION, 62),                  /* 318      MemManage exception */
00778     MBED_DEFINE_SYSTEM_ERROR(BUSFAULT_EXCEPTION, 63),                   /* 319      BusFault exception */
00779     MBED_DEFINE_SYSTEM_ERROR(USAGEFAULT_EXCEPTION, 64),                 /* 320      UsageFault exception*/
00780     MBED_DEFINE_SYSTEM_ERROR(BLE_NO_FRAME_INITIALIZED, 65),             /* 321      BLE No frame initialized */
00781     MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_CREATION_FAILED, 66),          /* 322      BLE Backend creation failed */
00782     MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_NOT_INITIALIZED, 67),          /* 323      BLE Backend not initialized */
00783 
00784     //Everytime you add a new system error code, you must update
00785     //Error documentation under Handbook to capture the info on
00786     //the new error status/codes
00787 
00788     //MBED CUSTOM ERROR CODE definitions starts at offset MBED_CUSTOM_ERROR_BASE, see above.
00789     /* Add More/Custom Error Codes here, See example below */
00790     //DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR     , 1 ),
00791 
00792 } mbed_error_code_t;
00793 
00794 /** mbed_error_ctx struct
00795  *
00796  *  This struct captures the context information at the time of error.\n
00797  *  It primarily contains information about the thread where the error originated,\n
00798  *  filename/line number of the source file where the error occurred, a context specific error value(error_value)\n
00799  *  and the address where the error originated.\n
00800  *
00801  *  @note
00802  *  Below are the members of mbed_error_ctx struct\n
00803  *      error_status              mbed_error_status_t value for this error\n
00804  *      error_function_address    Address where the error occurred\n
00805  *      thread_id                 ID of the thread which generated the error\n
00806  *      thread_entry_address      Entry function of the thread which generated the error\n
00807  *      thread_stack_size         Stack Size of the thread which generated the error\n
00808  *      thread_stack_mem          Stack Top of the thread which generated the error\n
00809  *      thread_current_sp         Current Stack Pointer of the thread which generated the error\n
00810  *      error_value               A context/error specific value associated with this error\n
00811  *      error_filename            Filename where the error originated\n
00812  *      error_line_number         Line number in error_filename where the error originated\n
00813  */
00814 typedef struct _mbed_error_ctx {
00815     mbed_error_status_t error_status;
00816     uint32_t error_address;
00817     uint32_t error_value;
00818     uint32_t thread_id;
00819     uint32_t thread_entry_address;
00820     uint32_t thread_stack_size;
00821     uint32_t thread_stack_mem;
00822     uint32_t thread_current_sp;
00823 #ifdef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
00824     char error_filename[MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN];
00825     uint32_t error_line_number;
00826 #endif
00827 } mbed_error_ctx;
00828 
00829 /** To generate a fatal compile-time error, you can use the pre-processor #error directive.
00830  *
00831  * @param format    C string that contains data stream to be printed.
00832  *                  Code snippets below show valid format.
00833  *
00834  * @code
00835  * #error "That shouldn't have happened!"
00836  * @endcode
00837  *
00838  * If the compiler evaluates this line, it will report the error and stop the compile.
00839  *
00840  * For example, you could use this to check some user-defined compile-time variables:
00841  *
00842  * @code
00843  * #define NUM_PORTS 7
00844  * #if (NUM_PORTS > 4)
00845  *     #error "NUM_PORTS must be less than 4"
00846  * #endif
00847  * @endcode
00848  *
00849  * Reporting Run-Time Errors:
00850  * To generate a fatal run-time error, you can use the mbed error() function.
00851  *
00852  * @code
00853  * error("That shouldn't have happened!");
00854  * @endcode
00855  *
00856  * If the mbed running the program executes this function, it will print the
00857  * message via the USB serial port, and then die with the blue lights of death!
00858  *
00859  * The message can use printf-style formatting, so you can report variables in the
00860  * message too. For example, you could use this to check a run-time condition:
00861  *
00862  * @code
00863  * if(x >= 5) {
00864  *     error("expected x to be less than 5, but got %d", x);
00865  * }
00866  * @endcode
00867  *
00868  *
00869  */
00870 
00871 void error(const char *format, ...);
00872 
00873 /**
00874  * Call this Macro to generate a mbed_error_status_t value for a System error
00875  * @param  module           Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
00876  * @param  error_code       The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes.
00877  *
00878  * @code
00879  *
00880  * mbed_error_status_t driver_error = MBED_MAKE_SYSTEM_ERROR( MODULE_DRIVER_USB, MBED_ERROR_CODE_INITIALIZATION_FAILED )
00881  *
00882  * @endcode
00883  * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
00884  *
00885  */
00886 #define MBED_MAKE_SYSTEM_ERROR(module, error_code)                   MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, module, error_code)
00887 
00888 /**
00889  * Call this Macro to generate a mbed_error_status_t value for a Custom error
00890  * @param  module           Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
00891  * @param  error_code       The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes.
00892  *
00893  * @code
00894  *
00895  * mbed_error_status_t custom_error = MBED_MAKE_CUSTOM_ERROR( MBED_MODULE_APPLICATION, 0xDEAD//16-bit custom error code )
00896  *
00897  * @endcode
00898  * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_CUSTOM
00899  *
00900  */
00901 #define MBED_MAKE_CUSTOM_ERROR(module, error_code)                   MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, module, error_code)
00902 
00903 /**
00904  * Call this Macro to generate a mbed_error_status_t value for a System error
00905  * @param  module           Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
00906  * @param  error_code       The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes.
00907  *
00908  * @code
00909  *
00910  * mbed_error_status_t new_error = MBED_MAKE_ERROR( MODULE_DRIVER_USB, MBED_ERROR_INITIALIZATION_FAILED )
00911  *
00912  * @endcode
00913  * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
00914  *
00915  */
00916 #define MBED_MAKE_ERROR(module, error_code)                          MBED_MAKE_SYSTEM_ERROR(module, error_code)
00917 
00918 /**
00919  * Callback/Error hook function prototype. Applications needing a callback when an error is reported can use mbed_set_error_hook function
00920  * to register a callback/error hook function using the following prototype. When an error happens in the system error handling
00921  * implementation will invoke this callback with the mbed_error_status_t reported and the error context at the time of error.
00922  * @param  error_status     mbed_error_status_t status being reported.
00923  * @param  error_ctx        Error context structure associated with this error.
00924  * @return                  void
00925  *
00926  */
00927 typedef void (*mbed_error_hook_t)(const mbed_error_ctx *error_ctx);
00928 
00929 /**
00930  * Call this function to set a system error/warning. This function will log the error status with the context info and return to caller.
00931  *
00932  * @param  error_status     mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
00933  * @param  error_msg        The error message to be printed out to STDIO/Serial.
00934  * @param  error_value      Value associated with the error status. This would depend on error code/error scenario.
00935  * @param  filename         Name of the source file originating the error( Most callers can pass __FILE__ here ).
00936  * @param  line_number      The line number of the source file originating the error( Most callers can pass __LINE__ here ) .
00937  * @return                  0 or MBED_SUCCESS.
00938  *                          MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
00939  *
00940  * @code
00941  *
00942  * mbed_error( ERROR_OUT_OF_MEMORY, "Out of memory error", 0, __FILE__, __LINE__ )
00943  *
00944  * @endcode
00945  *
00946  * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API
00947  */
00948 mbed_error_status_t mbed_warning(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number);
00949 
00950 /**
00951  * Returns the first system error reported.
00952  * @return                  mbed_error_status_t code logged for the first error or MBED_SUCCESS if no errors are logged.
00953  *
00954  */
00955 mbed_error_status_t mbed_get_first_error(void);
00956 
00957 /**
00958  * Returns the most recent system error reported.
00959  * @return                  mbed_error_status_t code logged for the last error or MBED_SUCCESS if no errors are logged.
00960  *
00961  */
00962 mbed_error_status_t mbed_get_last_error(void);
00963 
00964 /**
00965  * Returns the number of system errors reported after boot.
00966  * @return                  int Number of errors reported.
00967  *
00968  */
00969 int mbed_get_error_count(void);
00970 
00971 /**
00972  * Call this function to set a fatal system error and halt the system. This function will log the fatal error with the context info and prints the error report and halts the system.
00973  *
00974  * @param  error_status     mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
00975  * @param  error_msg        The error message to be printed out to STDIO/Serial.
00976  * @param  error_value      Value associated with the error status. This would depend on error code/error scenario.
00977  * @param  filename         Name of the source file originating the error( Most callers can pass __FILE__ here ).
00978  * @param  line_number      The line number of the source file originating the error( Most callers can pass __LINE__ here ) .
00979  * @return                  0 or MBED_SUCCESS.
00980  *                          MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
00981  *
00982  * @code
00983  *
00984  * mbed_error( MBED_ERROR_PROHIBITED_OPERATION, "Prohibited operation tried", 0, __FILE__, __LINE__ )
00985  *
00986  * @endcode
00987  *
00988  * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API
00989  */
00990 mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number);
00991 
00992 /**
00993  * Registers an application defined error callback with the error handling system.
00994  * This function will be called with error context info whenever system handles a mbed_error/mbed_warning call
00995  * NOTE: This function should be implemented for re-entrancy as multiple threads may invoke mbed_error which may cause error hook to be called.
00996  * @param  custom_error_hook    mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
00997  * @return                      0 or MBED_SUCCESS on success.
00998  *                              MBED_ERROR_INVALID_ARGUMENT in case of NULL for custom_error_hook
00999  *
01000  * @code
01001  *
01002  * mbed_error_status_t my_custom_error_hook(mbed_error_status_t error_status, const mbed_error_ctx *error_ctx) {
01003  *    //Do something with the error_status or error_ctx
01004  * }
01005  *
01006  * mbed_set_error_hook( my_custom_error_hook )
01007  *
01008  * @endcode
01009  * @note The erro hook function implementation should be re-entrant.
01010  *
01011  */
01012 mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t custom_error_hook);
01013 
01014 /**
01015  * Reads the first error context information captured.
01016  * @param  error_info           This is the mbed_error_context info captured as part of the first mbed_error call. The caller should pass a pointer to mbed_error_context struct allocated by the caller.
01017  * @return                      0 or MBED_SUCCESS on success.
01018  *                              MBED_ERROR_INVALID_ARGUMENT in case of invalid index
01019  *
01020  */
01021 mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info);
01022 
01023 /**
01024  * Reads the last error context information captured.
01025  * @param  error_info           This is the mbed_error_context info captured as part of the last mbed_error call. The caller should pass a pointer to mbed_error_context struct allocated by the caller.
01026  * @return                      0 or MBED_ERROR_SUCCESS on success.
01027  *                              MBED_ERROR_INVALID_ARGUMENT in case of invalid index
01028  *
01029  */
01030 mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info);
01031 
01032 /**
01033  * Clears the last error, first error, error count and all entries in the error history.
01034  * @return                      0 or MBED_SUCCESS on success.
01035  *
01036  */
01037 mbed_error_status_t mbed_clear_all_errors(void);
01038 
01039 /**
01040  * Generates a mbed_error_status_t value based on passed in values for type, module and error code.
01041  * @param  error_type           Error type based on mbed_error_type_t enum.
01042  * @param  module               Module type based on mbed_module_type_t enum.
01043  * @param  error_code           Error codes defined by mbed_error_code_t enum
01044  * @return                      0 or MBED_ERROR_SUCCESS on success.
01045  *
01046  */
01047 mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code);
01048 
01049 /**
01050  * Returns the current number of entries in the error history, if there has been more than max number of errors logged the number returned will be max depth of error history.
01051  * @return                      Current number of entries in the error history.
01052  *
01053  */
01054 int mbed_get_error_hist_count(void);
01055 
01056 /**
01057  * Reads the error context information for a specific error from error history, specified by the index.
01058  *
01059  * @param  index                index of the error context entry in the history to be retrieved.\n
01060  *                              The number of entries in the error history is configured during build and the max index depends on max depth of error history.\n
01061  *                              index = 0 points to the oldest entry in the history, and index = (max history depth - 1) points to the latest entry in the error history.\n
01062  * @param  error_info           This is the mbed_error_context info captured as part of the error history. The caller should pass a pointer to mbed_error_context struct allocated by the caller.
01063  * @return                      0 or MBED_SUCCESS on success.
01064  *                              MBED_ERROR_INVALID_ARGUMENT in case of invalid index
01065  *
01066  */
01067 mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info);
01068 
01069 /**
01070  * Saves the error history information to a file
01071  *
01072  * @param  path                 path to the file in the filesystem
01073  * @return                      0 or MBED_ERROR_SUCCESS on success.
01074  *                              MBED_ERROR_WRITE_FAILED if writing to file failed
01075  *                              MBED_ERROR_INVALID_ARGUMENT if path is not valid
01076  *
01077  * @note                        Filesystem support is required in order for this function to work.
01078  *
01079  */
01080 mbed_error_status_t mbed_save_error_hist(const char *path);
01081 
01082 #ifdef __cplusplus
01083 }
01084 #endif
01085 
01086 #endif
01087 
01088 /** @}*/
01089 /** @}*/
01090 
01091