source: asp3_tinet_ecnl_arm/trunk/asp3_dcre/mbed/platform/mbed_error.h@ 374

Last change on this file since 374 was 374, checked in by coas-nagasima, 5 years ago

mbed関連を更新
シリアルドライバをmbedのHALを使うよう変更
ファイルディスクリプタの処理を更新
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-chdr;charset=UTF-8
File size: 67.7 KB
Line 
1/** \addtogroup platform */
2/** @{*/
3/**
4 * \defgroup platform_error Error functions
5 * @{
6 */
7/* mbed Microcontroller Library
8 * Copyright (c) 2006-2013 ARM Limited
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
21 */
22#ifndef MBED_ERROR_H
23#define MBED_ERROR_H
24
25#include "platform/mbed_retarget.h"
26#include "platform/mbed_toolchain.h"
27
28#ifdef __cplusplus
29extern "C" {
30#endif
31
32/** Define this macro to include filenames in error context. For release builds, do not include filename to save memory.
33 * MBED_PLATFORM_CONF_ERROR_FILENAME_CAPTURE_ENABLED
34 */
35
36/** Define this macro to enable error history
37 * MBED_PLATFORM_CONF_ERROR_HIST_ENABLED
38 */
39
40#ifndef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
41#define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 16
42#else //MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
43#if MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN > 64
44//We have to limit this to 64 bytes since we use mbed_error_printf for error reporting
45//and mbed_error_vfprintf uses 128bytes internal buffer which may not be sufficient for anything
46//longer that 64 bytes with the current implementation.
47#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."
48#endif
49#endif
50
51#define MBED_ERROR_STATUS_CODE_MASK (0x0000FFFF)
52#define MBED_ERROR_STATUS_CODE_POS (0)
53#define MBED_ERROR_STATUS_CODE_FIELD_SIZE (16)
54
55#define MBED_ERROR_STATUS_MODULE_MASK (0x00FF0000)
56#define MBED_ERROR_STATUS_MODULE_POS (16)
57#define MBED_ERROR_STATUS_MODULE_FIELD_SIZE (8)
58
59#define MBED_ERROR_STATUS_TYPE_MASK (0x60000000)
60#define MBED_ERROR_STATUS_TYPE_POS (29)
61#define MBED_ERROR_STATUS_TYPE_FIELD_SIZE (2)
62
63/* mbed_error_status_t Status Encoding */
64//|31(1 bit) Always Negative|30-29(2 bits) |28-24 | 23-16(8 bits) | 15-0(16 bits) |
65//|-1 |TYPE |(unused/reserved) | MODULE TYPE | ERROR CODE |
66
67#define MAKE_MBED_ERROR(type, module, error_code) (mbed_error_status_t) \
68 ((0x80000000) | \
69 (MBED_ERROR_STATUS_CODE_MASK & (error_code << MBED_ERROR_STATUS_CODE_POS)) | \
70 (MBED_ERROR_STATUS_MODULE_MASK & (module << MBED_ERROR_STATUS_MODULE_POS)) | \
71 (MBED_ERROR_STATUS_TYPE_MASK & (type << MBED_ERROR_STATUS_TYPE_POS)))
72
73#define MBED_GET_ERROR_TYPE( error_status ) ((error_status & MBED_ERROR_STATUS_TYPE_MASK) >> MBED_ERROR_STATUS_TYPE_POS)
74#define MBED_GET_ERROR_MODULE( error_status ) ((error_status & MBED_ERROR_STATUS_MODULE_MASK) >> MBED_ERROR_STATUS_MODULE_POS)
75#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))
76
77/** mbed_error_status_t description
78 *
79 * 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
80 * Internally its encoded as below with bit-fields representing error type, module and error code:\n\n
81 * mbed_error_status_t Status Encoding:\n
82 *
83 \verbatim
84 | 31 Always Negative | 30-29(2 bits) | 28-24 | 23-16(8 bits) | 15-0(16 bits) |
85 | -1 | TYPE | (unused/reserved) | MODULE TYPE | ERROR CODE |
86 \endverbatim
87 *
88 * The error status value range for each error type is as follows:\n
89 * Posix Error Status-es - 0xFFFFFFFF to 0xFFFFFF01(-1 -255) - This corresponds to Posix error codes represented as negative.\n
90 * 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
91 * 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
92 *
93 * 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
94 * Posix Error Codes - 1 to 255.\n
95 * System Error Codes - 256 to 4095.\n
96 * Custom Error Codes - 4096 to 65535.\n
97 *
98 * @note Posix error codes are always encoded as negative of their actual value. For example, EPERM is encoded as -EPERM.
99 * And, the MODULE TYPE for Posix error codes are always encoded as MBED_MODULE_UNKNOWN.\n
100 * This is to enable easy injection of Posix error codes into MbedOS error handling system without altering the actual Posix error values.\n
101 * Accordingly, Posix error codes are represented as -1 to -255 under MbedOS error status representation.
102 */
103typedef int mbed_error_status_t;
104
105/**
106 * Macro for defining a Posix error status. This macro is mainly used to define Posix error values in mbed_error_code_t enumeration.
107 * @param error_name Name of the error without the ERROR_ prefix
108 * @param error_code Error code value to be used, must be between 1 and 255(inclusive).
109 *
110 */
111#define MBED_DEFINE_POSIX_ERROR( error_name, error_code ) \
112 MBED_ERROR_CODE_##error_name = error_code, \
113 MBED_ERROR_##error_name = -(MBED_POSIX_ERROR_BASE + error_code)
114
115/**
116 * Macro for defining a System error status. This macro is used to define System error values in mbed_error_code_t enumeration.
117 * @param error_name Name of the error without the ERROR_ prefix
118 * @param error_code Error code value to be used, must be between 256 and 4096(inclusive).
119 *
120 */
121#define MBED_DEFINE_SYSTEM_ERROR( error_name, error_code ) \
122 MBED_ERROR_CODE_##error_name = MBED_SYSTEM_ERROR_BASE + error_code, \
123 MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
124
125/**
126 * Macro for defining a Custom error status. This macro is used to define custom error values in mbed_error_code_t enumeration.
127 * @param error_name Name of the error without the ERROR_ prefix
128 * @param error_code Error code value to be used, must be between 4097 and 65535(inclusive).
129 *
130 */
131#define MBED_DEFINE_CUSTOM_ERROR( error_name, error_code ) \
132 MBED_ERROR_CODE_##error_name = MBED_CUSTOM_ERROR_BASE + error_code, \
133 MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
134
135
136/**
137 * Macros for setting a system warning. These macros will log the error, Its a wrapper for calling mbed_warning API.
138 * There are 2 versions of this macro. MBED_WARNING takes status and message. MBED_WARNING1 takes an additional context specific argument
139 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
140 * @param error_msg The error message to be printed out to STDIO/Serial.
141 * @param error_value Value associated with the error status. This would depend on error code/error scenario.
142 *
143 * @code
144 *
145 * MBED_WARNING( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read" )
146 * MBED_WARNING1( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read", size_val )
147 *
148 * @endcode
149 * @note The macro calls mbed_warning API with filename and line number info without caller explicitly passing them.
150 * 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.
151 *
152 */
153#ifdef NDEBUG
154#define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 )
155#define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)NULL, (uint32_t)0, NULL, 0 )
156#else //NDEBUG
157#if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
158#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__ )
159#define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)0 , (const char *)MBED_FILENAME, __LINE__ )
160#else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
161#define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 )
162#define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)0, NULL, 0 )
163#endif
164#endif
165
166/**
167 * 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.
168 * There are 2 versions of this macro. MBED_ERROR takes status and message. MBED_ERROR1 takes an additional context specific argument
169 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
170 * @param error_msg The error message to be printed out to STDIO/Serial.
171 * @param error_value Value associated with the error status. This would depend on error code/error scenario. Only available with MBED_ERROR1
172 * @return 0 or MBED_SUCCESS.
173 * MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
174 *
175 * @code
176 *
177 * MBED_ERROR( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex" )
178 * MBED_ERROR1( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex", &my_mutex )
179 *
180 * @endcode
181 * @note The macro calls mbed_error API with filename and line number info without caller explicitly passing them.
182 * 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.
183 *
184 */
185#ifdef NDEBUG
186#define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 )
187#define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)NULL, (uint32_t)0 , NULL, 0 )
188#else //NDEBUG
189#if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
190#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__ )
191#define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)error_msg, (uint32_t)0 , (const char *)MBED_FILENAME, __LINE__ )
192#else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
193#define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 )
194#define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)error_msg, (uint32_t)0 , NULL, 0 )
195#endif
196#endif
197
198//Error Type definition
199/** mbed_error_type_t definition
200 * @note
201 * This enumeration defines the Error types supported. The value of these enum values will be encoded into mbed_error_status_t TYPE field.\n
202 * See mbed_error_status_t description for more info.\n
203 * MBED_ERROR_TYPE_SYSTEM - Used to indicate that the error status is of System defined Error type.\n
204 * MBED_ERROR_TYPE_CUSTOM - Used to indicate that the error status is of Custom defined Error type.\n
205 * MBED_ERROR_TYPE_POSIX - Used to indicate that the error status is of Posix error type.\n
206 *
207 */
208typedef enum _mbed_error_type_t {
209 MBED_ERROR_TYPE_SYSTEM = 0,
210 MBED_ERROR_TYPE_CUSTOM = 1,
211 //2 is reserved
212 //Use 3 for POSIX because we are mapping -1 to -255 to POSIX error codes
213 //and thus we must use 3 to match the type bits in error status representation which are from 0xFFFFFFFF to 0xFFFFFF00
214 MBED_ERROR_TYPE_POSIX = 3
215} mbed_error_type_t;
216
217//Module type/id definitions
218/** mbed_module_type_t definition
219 * @note
220 * This enumeration defines the module types. The value of these enum values will be encoded into mbed_error_status_t MODULE field.\n\n
221 * See mbed_error_status_t description for more info.\n
222 * 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
223 * Other module values can be used to provide more info on who/where the error originated from.\n\n
224 * For example, if I2C driver is the component originating the error you can use MBED_MODULE_DRIVER_I2C to provide more info.\n
225 * Its used in call to MBED_MAKE_ERROR/MBED_MAKE_SYSTEM_ERROR/MBED_MAKE_CUSTOM_ERROR macros.\n
226 *
227 * @code
228 * Example: mbed_error_status_t i2c_driver_error = MBED_MAKE_ERROR( MBED_MODULE_DRIVER_I2C, MBED_ERROR_CONFIG_UNSUPPORTED );
229 * @endcode
230 *
231 * @note
232 * \n Below are the module code mappings:\n
233 \verbatim
234 MBED_MODULE_APPLICATION 0 Application
235 MBED_MODULE_PLATFORM 1 Platform
236 MODULE_KERNEL 2 RTX Kernel
237 MBED_MODULE_NETWORK_STACK 3 Network stack
238 MBED_MODULE_HAL 4 HAL - Hardware Abstraction Layer
239 MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem
240 MBED_MODULE_FILESYSTEM 6 Filesystem
241 MBED_MODULE_BLOCK_DEVICE 7 Block device
242 MBED_MODULE_DRIVER 8 Driver
243 MBED_MODULE_DRIVER_SERIAL 9 Serial Driver
244 MBED_MODULE_DRIVER_RTC 10 RTC Driver
245 MBED_MODULE_DRIVER_I2C 11 I2C Driver
246 MODULE_DRIVER_SPI 12 SPI Driver
247 MODULE_DRIVER_GPIO 13 GPIO Driver
248 MODULE_DRIVER_ANALOG 14 Analog Driver
249 MODULE_DRIVER_DIGITAL 15 DigitalIO Driver
250 MODULE_DRIVER_CAN 16 CAN Driver
251 MODULE_DRIVER_ETHERNET 17 Ethernet Driver
252 MODULE_DRIVER_CRC 18 CRC Module
253 MODULE_DRIVER_PWM 19 PWM Driver
254 MODULE_DRIVER_QSPI 20 QSPI Driver
255 MODULE_DRIVER_USB 21 USB Driver
256 MODULE_TARGET_SDK 22 SDK
257
258 MBED_MODULE_UNKNOWN 255 Unknown module
259 \endverbatim
260 *
261 */
262typedef enum _mbed_module_type {
263 MBED_MODULE_APPLICATION = 0,
264 MBED_MODULE_PLATFORM,
265 MBED_MODULE_KERNEL,
266 MBED_MODULE_NETWORK_STACK,
267 MBED_MODULE_HAL,
268 MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM,
269 MBED_MODULE_FILESYSTEM,
270 MBED_MODULE_BLOCK_DEVICE,
271 MBED_MODULE_DRIVER,
272 MBED_MODULE_DRIVER_SERIAL,
273 MBED_MODULE_DRIVER_RTC,
274 MBED_MODULE_DRIVER_I2C,
275 MBED_MODULE_DRIVER_SPI,
276 MBED_MODULE_DRIVER_GPIO,
277 MBED_MODULE_DRIVER_ANALOG,
278 MBED_MODULE_DRIVER_DIGITAL,
279 MBED_MODULE_DRIVER_CAN,
280 MBED_MODULE_DRIVER_ETHERNET,
281 MBED_MODULE_DRIVER_CRC,
282 MBED_MODULE_DRIVER_PWM,
283 MBED_MODULE_DRIVER_QSPI,
284 MBED_MODULE_DRIVER_USB,
285 MBED_MODULE_TARGET_SDK,
286 MBED_MODULE_BLE,
287 /* Add More entities here as required */
288
289 MBED_MODULE_UNKNOWN = 255,
290 MBED_MODULE_MAX = MBED_MODULE_UNKNOWN
291} mbed_module_type_t;
292
293//Use MBED_SUCCESS(=0) or any postive number for successful returns
294#define MBED_SUCCESS 0
295
296#define MBED_POSIX_ERROR_BASE 0
297#define MBED_SYSTEM_ERROR_BASE 256
298#define MBED_CUSTOM_ERROR_BASE 4096
299
300//Error Code definitions
301/** mbed_error_code_t definition
302 *
303 * mbed_error_code_t enumeration defines the Error codes and Error status values for MBED_MODULE_UNKNOWN.\n
304 * It defines all of Posix Error Codes/Statuses and Mbed System Error Codes/Statuses.\n\n
305 *
306 * @note
307 * Posix Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n
308 * For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This effectively defines the following values:\n
309 * ERROR_CODE_EPERM = EPERM\n
310 * ERROR_EPERM = -EPERM\n
311 *
312 * Posix Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n
313 * For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This macro defines the following values:\n
314 * ERROR_CODE_EPERM = MBED_POSIX_ERROR_BASE+EPERM\n
315 * ERROR_EPERM = -(MBED_POSIX_ERROR_BASE+EPERM)\n
316 * Its effectively equivalent to:\n
317 * ERROR_CODE_EPERM = 1\n
318 * ERROR_EPERM = -1\n
319 * All Posix error codes currently supported by MbedOS(defined in mbed_retarget.h) are defined using the MBED_DEFINE_POSIX_ERROR macro.\n\n
320 * Below are the Posic error codes and the description:\n
321 * \verbatim
322 EPERM 1 Operation not permitted
323 ENOENT 2 No such file or directory
324 ESRCH 3 No such process
325 EINTR 4 Interrupted system call
326 EIO 5 I/O error
327 ENXIO 6 No such device or address
328 E2BIG 7 Argument list too long
329 ENOEXEC 8 Exec format error
330 EBADF 9 Bad file number
331 ECHILD 10 No child processes
332 EAGAIN 11 Try again
333 ENOMEM 12 Out of memory
334 EACCES 13 Permission denied
335 EFAULT 14 Bad address
336 ENOTBLK 15 Block device required
337 EBUSY 16 Device or resource busy
338 EEXIST 17 File exists
339 EXDEV 18 Cross-device link
340 ENODEV 19 No such device
341 ENOTDIR 20 Not a directory
342 EISDIR 21 Is a directory
343 EINVAL 22 Invalid argument
344 ENFILE 23 File table overflow
345 EMFILE 24 Too many open files
346 ENOTTY 25 Not a typewriter
347 ETXTBSY 26 Text file busy
348 EFBIG 27 File too large
349 ENOSPC 28 No space left on device
350 ESPIPE 29 Illegal seek
351 EROFS 30 Read-only file system
352 EMLINK 31 Too many links
353 EPIPE 32 Broken pipe
354 EDOM 33 Math argument out of domain of func
355 ERANGE 34 Math result not representable
356 EDEADLK 35 Resource deadlock would occur
357 ENAMETOOLONG 36 File name too long
358 ENOLCK 37 No record locks available
359 ENOSYS 38 Function not implemented
360 ENOTEMPTY 39 Directory not empty
361 ELOOP 40 Too many symbolic links encountered
362 EWOULDBLOCK EAGAIN Operation would block
363 ENOMSG 42 No message of desired type
364 EIDRM 43 Identifier removed
365 ECHRNG 44 Channel number out of range
366 EL2NSYNC 45 Level 2 not synchronized
367 EL3HLT 46 Level 3 halted
368 EL3RST 47 Level 3 reset
369 ELNRNG 48 Link number out of range
370 EUNATCH 49 Protocol driver not attached
371 ENOCSI 50 No CSI structure available
372 EL2HLT 51 Level 2 halted
373 EBADE 52 Invalid exchange
374 EBADR 53 Invalid request descriptor
375 EXFULL 54 Exchange full
376 ENOANO 55 No anode
377 EBADRQC 56 Invalid request code
378 EBADSLT 57 Invalid slot
379 EDEADLOCK EDEADLK Resource deadlock would occur
380 EBFONT 59 Bad font file format
381 ENOSTR 60 Device not a stream
382 ENODATA 61 No data available
383 ETIME 62 Timer expired
384 ENOSR 63 Out of streams resources
385 ENONET 64 Machine is not on the network
386 ENOPKG 65 Package not installed
387 EREMOTE 66 Object is remote
388 ENOLINK 67 Link has been severed
389 EADV 68 Advertise error
390 ESRMNT 69 Srmount error
391 ECOMM 70 Communication error on send
392 EPROTO 71 Protocol error
393 EMULTIHOP 72 Multihop attempted
394 EDOTDOT 73 RFS specific error
395 EBADMSG 74 Not a data message
396 EOVERFLOW 75 Value too large for defined data type
397 ENOTUNIQ 76 Name not unique on network
398 EBADFD 77 File descriptor in bad state
399 EREMCHG 78 Remote address changed
400 ELIBACC 79 Can not access a needed shared library
401 ELIBBAD 80 Accessing a corrupted shared library
402 ELIBSCN 81 .lib section in a.out corrupted
403 ELIBMAX 82 Attempting to link in too many shared libraries
404 ELIBEXEC 83 Cannot exec a shared library directly
405 EILSEQ 84 Illegal byte sequence
406 ERESTART 85 Interrupted system call should be restarted
407 ESTRPIPE 86 Streams pipe error
408 EUSERS 87 Too many users
409 ENOTSOCK 88 Socket operation on non-socket
410 EDESTADDRREQ 89 Destination address required
411 EMSGSIZE 90 Message too long
412 EPROTOTYPE 91 Protocol wrong type for socket
413 ENOPROTOOPT 92 Protocol not available
414 EPROTONOSUPPORT 93 Protocol not supported
415 ESOCKTNOSUPPORT 94 Socket type not supported
416 EOPNOTSUPP 95 Operation not supported on transport endpoint
417 EPFNOSUPPORT 96 Protocol family not supported
418 EAFNOSUPPORT 97 Address family not supported by protocol
419 EADDRINUSE 98 Address already in use
420 EADDRNOTAVAIL 99 Cannot assign requested address
421 ENETDOWN 100 Network is down
422 ENETUNREACH 101 Network is unreachable
423 ENETRESET 102 Network dropped connection because of reset
424 ECONNABORTED 103 Software caused connection abort
425 ECONNRESET 104 Connection reset by peer
426 ENOBUFS 105 No buffer space available
427 EISCONN 106 Transport endpoint is already connected
428 ENOTCONN 107 Transport endpoint is not connected
429 ESHUTDOWN 108 Cannot send after transport endpoint shutdown
430 ETOOMANYREFS 109 Too many references: cannot splice
431 ETIMEDOUT 110 Connection timed out
432 ECONNREFUSED 111 Connection refused
433 EHOSTDOWN 112 Host is down
434 EHOSTUNREACH 113 No route to host
435 EALREADY 114 Operation already in progress
436 EINPROGRESS 115 Operation now in progress
437 ESTALE 116 Stale NFS file handle
438 EUCLEAN 117 Structure needs cleaning
439 ENOTNAM 118 Not a XENIX named type file
440 ENAVAIL 119 No XENIX semaphores available
441 EISNAM 120 Is a named type file
442 EREMOTEIO 121 Remote I/O error
443 EDQUOT 122 Quota exceeded
444 ENOMEDIUM 123 No medium found
445 EMEDIUMTYPE 124 Wrong medium type
446 ECANCELED 125 Operation Canceled
447 ENOKEY 126 Required key not available
448 EKEYEXPIRED 127 Key has expired
449 EKEYREVOKED 128 Key has been revoked
450 EKEYREJECTED 129 Key was rejected by service
451 EOWNERDEAD 130 Owner died
452 ENOTRECOVERABLE 131 State not recoverable
453 \endverbatim
454 *
455 * @note
456 * MbedOS System Error codes are defined using the macro MBED_DEFINE_SYSTEM_ERROR\n
457 * For example MBED_DEFINE_SYSTEM_ERROR( INVALID_ARGUMENT ,1 ) macro defines the following values:\n
458 * ERROR_CODE_INVALID_ARGUMENT = MBED_SYSTEM_ERROR_BASE+1\n
459 * ERROR_INVALID_ARGUMENT = MAKE_MBED_ERROR(ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, ERROR_CODE_INVALID_ARGUMENT)\n
460 * Its effectively equivalent to:\n
461 * ERROR_CODE_INVALID_ARGUMENT = 1\n
462 * ERROR_INVALID_ARGUMENT = 0x80FF0001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN)
463 * New System Error codes should be defined using MBED_DEFINE_SYSTEM_ERROR macro and must have an unique error code value\n
464 * passed as the second argument in the MBED_DEFINE_SYSTEM_ERROR macro.\n\n
465 * Below are the Mbed System error codes and the description:
466 * \verbatim
467 UNKNOWN 256 Unknown error
468 INVALID_ARGUMENT 257 Invalid Argument
469 INVALID_DATA 258 Invalid data
470 INVALID_FORMAT 259 Invalid format
471 INVALID_INDEX 260 Invalid Index
472 INVALID_SIZE 261 Inavlid Size
473 INVALID_OPERATION 262 Invalid Operation
474 NOT_FOUND 263 Not Found
475 ACCESS_DENIED 264 Access Denied
476 NOT_SUPPORTED 265 Not supported
477 BUFFER_FULL 266 Buffer Full
478 MEDIA_FULL 267 Media/Disk Full
479 ALREADY_IN_USE 268 Already in use
480 TIMEOUT 269 Timeout error
481 NOT_READY 270 Not Ready
482 FAILED_OPERATION 271 Requested Operation failed
483 OPERATION_PROHIBITED 272 Operation prohibited
484 OPERATION_ABORTED 273 Operation failed
485 WRITE_PROTECTED 274 Attempt to write to write-protected resource
486 NO_RESPONSE 275 No response
487 SEMAPHORE_LOCK_FAILED 276 Sempahore lock failed
488 MUTEX_LOCK_FAILED 277 Mutex lock failed
489 SEMAPHORE_UNLOCK_FAILED 278 Sempahore unlock failed
490 MUTEX_UNLOCK_FAILED 279 Mutex unlock failed
491 CRC_ERROR 280 CRC error or mismatch
492 OPEN_FAILED 281 Open failed
493 CLOSE_FAILED 282 Close failed
494 READ_FAILED 283 Read failed
495 WRITE_FAILED 284 Write failed
496 INITIALIZATION_FAILED 285 Initialization failed
497 BOOT_FAILURE 286 Boot failure
498 OUT_OF_MEMORY 287 Out of memory
499 OUT_OF_RESOURCES 288 Out of resources
500 ALLOC_FAILED 289 Alloc failed
501 FREE_FAILED 290 Free failed
502 OVERFLOW 291 Overflow error
503 UNDERFLOW 292 Underflow error
504 STACK_OVERFLOW 293 Stack overflow error
505 ISR_QUEUE_OVERFLOW 294 ISR queue overflow
506 TIMER_QUEUE_OVERFLOW 295 Timer Queue overflow
507 CLIB_SPACE_UNAVAILABLE 296 Standard library error - Space unavailable
508 CLIB_EXCEPTION 297 Standard library error - Exception
509 CLIB_MUTEX_INIT_FAILURE 298 Standard library error - Mutex Init failure
510 CREATE_FAILED 299 Create failed
511 DELETE_FAILED 300 Delete failed
512 THREAD_CREATE_FAILED 301 Thread Create failed
513 THREAD_DELETE_FAILED 302 Thread Delete failed
514 PROHIBITED_IN_ISR_CONTEXT 303 Operation Prohibited in ISR context
515 PINMAP_INVALID 304 Pinmap Invalid
516 RTOS_EVENT 305 Unknown Rtos Error
517 RTOS_THREAD_EVENT 306 Rtos Thread Error
518 RTOS_MUTEX_EVENT 307 Rtos Mutex Error
519 RTOS_SEMAPHORE_EVENT 308 Rtos Semaphore Error
520 RTOS_MEMORY_POOL_EVENT 309 Rtos Memory Pool Error
521 RTOS_TIMER_EVENT 310 Rtos Timer Error
522 RTOS_EVENT_FLAGS_EVENT 311 Rtos Event flags Error
523 RTOS_MESSAGE_QUEUE_EVENT 312 Rtos Message queue Error
524 DEVICE_BUSY 313 Device Busy
525 CONFIG_UNSUPPORTED 314 Configuration not supported
526 CONFIG_MISMATCH 315 Configuration mismatch
527 ALREADY_INITIALIZED 316 Already initialzied
528 HARDFAULT_EXCEPTION 317 HardFault exception
529 MEMMANAGE_EXCEPTION 318 MemManage exception
530 BUSFAULT_EXCEPTION 319 BusFault exception
531 USAGEFAULT_EXCEPTION 320 UsageFault exception
532 \endverbatim
533 *
534 * @note
535 * Custom Error codes can be defined using the macro DEFINE_CUSTOM_ERROR\n
536 * This is mainly meant to capture non-generic error codes specific to a device.
537 * For example DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR ,1 ) macro defines the following values:\n
538 * ERROR_CODE_MY_CUSTOM_ERROR = MBED_CUSTOM_ERROR_BASE+1\n
539 * ERROR_MY_CUSTOM_ERROR = MAKE_MBED_ERROR(ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, ERROR_CODE_MY_CUSTOM_ERROR)\n
540 * Its effectively equivalent to:\n
541 * ERROR_CODE_MY_CUSTOM_ERROR = 4097\n
542 * ERROR_MY_CUSTOM_ERROR = 0xA0FF1001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN) \n\n
543 *
544 * @note
545 * **Using error codes:** \n
546 * Posix error codes may be used in modules/functions currently using Posix error codes and switching them to Mbed-OS error codes
547 * may cause interoperability issues. For example, some of the filesystem, network stack implementations may need to use
548 * Posix error codes in order to keep them compatible with other modules interfacing with them, and may continue to use Posix error codes.
549 *
550 * In all other cases, like for any native development of Mbed-OS modules Mbed-OS error codes should be used.
551 * This makes it easy to use Mbed-OS error reporting/logging infrastructure and makes debugging error scenarios
552 * much more efficient.
553 *
554 * @note
555 * **Searching for error codes in mbed-os source tree:** \n
556 * 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
557 * 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
558 * Use that error name(\b INVALID_FORMAT) to search the source tree for code locations setting that specific error code. \n
559 * 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.
560 * See mbed_module_type_t enum above for module mapping. \n
561 *
562 * \verbatim
563 ++ MbedOS Error Info ++
564 Error Status: 0x80040103
565 Error Code: 259
566 Error Module: 04
567 Error Message: HAL Module error
568 Error Location: 0x000067C7
569 Error Value: 0x00005566
570 Current Thread: Id: 0x200024A8 EntryFn: 0x0000FB0D StackSize: 0x00001000 StackMem: 0x200014A8 SP: 0x2002FFD8
571 -- MbedOS Error Info --
572 \endverbatim
573 */
574
575typedef enum _mbed_error_code {
576 //Below are POSIX ERROR CODE definitions, which starts at MBED_POSIX_ERROR_BASE(=0)
577 //POSIX ERROR CODE definitions starts at offset 0(MBED_POSIX_ERROR_BASE) to align them with actual Posix Error Code
578 //defintions in mbed_retarget.h
579 // Error Name Error Code
580 MBED_DEFINE_POSIX_ERROR(EPERM, EPERM), /* 1 Operation not permitted */
581 MBED_DEFINE_POSIX_ERROR(ENOENT, ENOENT), /* 2 No such file or directory */
582 MBED_DEFINE_POSIX_ERROR(ESRCH, ESRCH), /* 3 No such process */
583 MBED_DEFINE_POSIX_ERROR(EINTR, EINTR), /* 4 Interrupted system call */
584 MBED_DEFINE_POSIX_ERROR(EIO, EIO), /* 5 I/O error */
585 MBED_DEFINE_POSIX_ERROR(ENXIO, ENXIO), /* 6 No such device or address */
586 MBED_DEFINE_POSIX_ERROR(E2BIG, E2BIG), /* 7 Argument list too long */
587 MBED_DEFINE_POSIX_ERROR(ENOEXEC, ENOEXEC), /* 8 Exec format error */
588 MBED_DEFINE_POSIX_ERROR(EBADF, EBADF), /* 9 Bad file number */
589 MBED_DEFINE_POSIX_ERROR(ECHILD, ECHILD), /* 10 No child processes */
590 MBED_DEFINE_POSIX_ERROR(EAGAIN, EAGAIN), /* 11 Try again */
591 MBED_DEFINE_POSIX_ERROR(ENOMEM, ENOMEM), /* 12 Out of memory */
592 MBED_DEFINE_POSIX_ERROR(EACCES, EACCES), /* 13 Permission denied */
593 MBED_DEFINE_POSIX_ERROR(EFAULT, EFAULT), /* 14 Bad address */
594 MBED_DEFINE_POSIX_ERROR(ENOTBLK, ENOTBLK), /* 15 Block device required */
595 MBED_DEFINE_POSIX_ERROR(EBUSY, EBUSY), /* 16 Device or resource busy */
596 MBED_DEFINE_POSIX_ERROR(EEXIST, EEXIST), /* 17 File exists */
597 MBED_DEFINE_POSIX_ERROR(EXDEV, EXDEV), /* 18 Cross-device link */
598 MBED_DEFINE_POSIX_ERROR(ENODEV, ENODEV), /* 19 No such device */
599 MBED_DEFINE_POSIX_ERROR(ENOTDIR, ENOTDIR), /* 20 Not a directory */
600 MBED_DEFINE_POSIX_ERROR(EISDIR, EISDIR), /* 21 Is a directory */
601 MBED_DEFINE_POSIX_ERROR(EINVAL, EINVAL), /* 22 Invalid argument */
602 MBED_DEFINE_POSIX_ERROR(ENFILE, ENFILE), /* 23 File table overflow */
603 MBED_DEFINE_POSIX_ERROR(EMFILE, EMFILE), /* 24 Too many open files */
604 MBED_DEFINE_POSIX_ERROR(ENOTTY, ENOTTY), /* 25 Not a typewriter */
605 MBED_DEFINE_POSIX_ERROR(ETXTBSY, ETXTBSY), /* 26 Text file busy */
606 MBED_DEFINE_POSIX_ERROR(EFBIG, EFBIG), /* 27 File too large */
607 MBED_DEFINE_POSIX_ERROR(ENOSPC, ENOSPC), /* 28 No space left on device */
608 MBED_DEFINE_POSIX_ERROR(ESPIPE, ESPIPE), /* 29 Illegal seek */
609 MBED_DEFINE_POSIX_ERROR(EROFS, EROFS), /* 30 Read-only file system */
610 MBED_DEFINE_POSIX_ERROR(EMLINK, EMLINK), /* 31 Too many links */
611 MBED_DEFINE_POSIX_ERROR(EPIPE, EPIPE), /* 32 Broken pipe */
612 MBED_DEFINE_POSIX_ERROR(EDOM, EDOM), /* 33 Math argument out of domain of func */
613 MBED_DEFINE_POSIX_ERROR(ERANGE, ERANGE), /* 34 Math result not representable */
614 MBED_DEFINE_POSIX_ERROR(EDEADLK, EDEADLK), /* 35 Resource deadlock would occur */
615 MBED_DEFINE_POSIX_ERROR(ENAMETOOLONG, ENAMETOOLONG), /* 36 File name too long */
616 MBED_DEFINE_POSIX_ERROR(ENOLCK, ENOLCK), /* 37 No record locks available */
617 MBED_DEFINE_POSIX_ERROR(ENOSYS, ENOSYS), /* 38 Function not implemented */
618 MBED_DEFINE_POSIX_ERROR(ENOTEMPTY, ENOTEMPTY), /* 39 Directory not empty */
619 MBED_DEFINE_POSIX_ERROR(ELOOP, ELOOP), /* 40 Too many symbolic links encountered */
620 MBED_DEFINE_POSIX_ERROR(EWOULDBLOCK, EAGAIN), /* EAGAIN Operation would block */
621 MBED_DEFINE_POSIX_ERROR(ENOMSG, ENOMSG), /* 42 No message of desired type */
622 MBED_DEFINE_POSIX_ERROR(EIDRM, EIDRM), /* 43 Identifier removed */
623 MBED_DEFINE_POSIX_ERROR(ECHRNG, ECHRNG), /* 44 Channel number out of range */
624 MBED_DEFINE_POSIX_ERROR(EL2NSYNC, EL2NSYNC), /* 45 Level 2 not synchronized */
625 MBED_DEFINE_POSIX_ERROR(EL3HLT, EL3HLT), /* 46 Level 3 halted */
626 MBED_DEFINE_POSIX_ERROR(EL3RST, EL3RST), /* 47 Level 3 reset */
627 MBED_DEFINE_POSIX_ERROR(ELNRNG, ELNRNG), /* 48 Link number out of range */
628 MBED_DEFINE_POSIX_ERROR(EUNATCH, EUNATCH), /* 49 Protocol driver not attached */
629 MBED_DEFINE_POSIX_ERROR(ENOCSI, ENOCSI), /* 50 No CSI structure available */
630 MBED_DEFINE_POSIX_ERROR(EL2HLT, EL2HLT), /* 51 Level 2 halted */
631 MBED_DEFINE_POSIX_ERROR(EBADE, EBADE), /* 52 Invalid exchange */
632 MBED_DEFINE_POSIX_ERROR(EBADR, EBADR), /* 53 Invalid request descriptor */
633 MBED_DEFINE_POSIX_ERROR(EXFULL, EXFULL), /* 54 Exchange full */
634 MBED_DEFINE_POSIX_ERROR(ENOANO, ENOANO), /* 55 No anode */
635 MBED_DEFINE_POSIX_ERROR(EBADRQC, EBADRQC), /* 56 Invalid request code */
636 MBED_DEFINE_POSIX_ERROR(EBADSLT, EBADSLT), /* 57 Invalid slot */
637 MBED_DEFINE_POSIX_ERROR(EDEADLOCK, EDEADLK), /* EDEADLK Resource deadlock would occur */
638 MBED_DEFINE_POSIX_ERROR(EBFONT, EBFONT), /* 59 Bad font file format */
639 MBED_DEFINE_POSIX_ERROR(ENOSTR, ENOSTR), /* 60 Device not a stream */
640 MBED_DEFINE_POSIX_ERROR(ENODATA, ENODATA), /* 61 No data available */
641 MBED_DEFINE_POSIX_ERROR(ETIME, ETIME), /* 62 Timer expired */
642 MBED_DEFINE_POSIX_ERROR(ENOSR, ENOSR), /* 63 Out of streams resources */
643 MBED_DEFINE_POSIX_ERROR(ENONET, ENONET), /* 64 Machine is not on the network */
644 MBED_DEFINE_POSIX_ERROR(ENOPKG, ENOPKG), /* 65 Package not installed */
645 MBED_DEFINE_POSIX_ERROR(EREMOTE, EREMOTE), /* 66 Object is remote */
646 MBED_DEFINE_POSIX_ERROR(ENOLINK, ENOLINK), /* 67 Link has been severed */
647 MBED_DEFINE_POSIX_ERROR(EADV, EADV), /* 68 Advertise error */
648 MBED_DEFINE_POSIX_ERROR(ESRMNT, ESRMNT), /* 69 Srmount error */
649 MBED_DEFINE_POSIX_ERROR(ECOMM, ECOMM), /* 70 Communication error on send */
650 MBED_DEFINE_POSIX_ERROR(EPROTO, EPROTO), /* 71 Protocol error */
651 MBED_DEFINE_POSIX_ERROR(EMULTIHOP, EMULTIHOP), /* 72 Multihop attempted */
652 MBED_DEFINE_POSIX_ERROR(EDOTDOT, EDOTDOT), /* 73 RFS specific error */
653 MBED_DEFINE_POSIX_ERROR(EBADMSG, EBADMSG), /* 74 Not a data message */
654 MBED_DEFINE_POSIX_ERROR(EOVERFLOW, EOVERFLOW), /* 75 Value too large for defined data type */
655 MBED_DEFINE_POSIX_ERROR(ENOTUNIQ, ENOTUNIQ), /* 76 Name not unique on network */
656 MBED_DEFINE_POSIX_ERROR(EBADFD, EBADFD), /* 77 File descriptor in bad state */
657 MBED_DEFINE_POSIX_ERROR(EREMCHG, EREMCHG), /* 78 Remote address changed */
658 MBED_DEFINE_POSIX_ERROR(ELIBACC, ELIBACC), /* 79 Can not access a needed shared library */
659 MBED_DEFINE_POSIX_ERROR(ELIBBAD, ELIBBAD), /* 80 Accessing a corrupted shared library */
660 MBED_DEFINE_POSIX_ERROR(ELIBSCN, ELIBSCN), /* 81 .lib section in a.out corrupted */
661 MBED_DEFINE_POSIX_ERROR(ELIBMAX, ELIBMAX), /* 82 Attempting to link in too many shared libraries */
662 MBED_DEFINE_POSIX_ERROR(ELIBEXEC, ELIBEXEC), /* 83 Cannot exec a shared library directly */
663 MBED_DEFINE_POSIX_ERROR(EILSEQ, EILSEQ), /* 84 Illegal byte sequence */
664 MBED_DEFINE_POSIX_ERROR(ERESTART, ERESTART), /* 85 Interrupted system call should be restarted */
665 MBED_DEFINE_POSIX_ERROR(ESTRPIPE, ESTRPIPE), /* 86 Streams pipe error */
666 MBED_DEFINE_POSIX_ERROR(EUSERS, EUSERS), /* 87 Too many users */
667 MBED_DEFINE_POSIX_ERROR(ENOTSOCK, ENOTSOCK), /* 88 Socket operation on non-socket */
668 MBED_DEFINE_POSIX_ERROR(EDESTADDRREQ, EDESTADDRREQ), /* 89 Destination address required */
669 MBED_DEFINE_POSIX_ERROR(EMSGSIZE, EMSGSIZE), /* 90 Message too long */
670 MBED_DEFINE_POSIX_ERROR(EPROTOTYPE, EPROTOTYPE), /* 91 Protocol wrong type for socket */
671 MBED_DEFINE_POSIX_ERROR(ENOPROTOOPT, ENOPROTOOPT), /* 92 Protocol not available */
672 MBED_DEFINE_POSIX_ERROR(EPROTONOSUPPORT, EPROTONOSUPPORT), /* 93 Protocol not supported */
673 MBED_DEFINE_POSIX_ERROR(ESOCKTNOSUPPORT, ESOCKTNOSUPPORT), /* 94 Socket type not supported */
674 MBED_DEFINE_POSIX_ERROR(EOPNOTSUPP, EOPNOTSUPP), /* 95 Operation not supported on transport endpoint */
675 MBED_DEFINE_POSIX_ERROR(EPFNOSUPPORT, EPFNOSUPPORT), /* 96 Protocol family not supported */
676 MBED_DEFINE_POSIX_ERROR(EAFNOSUPPORT, EAFNOSUPPORT), /* 97 Address family not supported by protocol */
677 MBED_DEFINE_POSIX_ERROR(EADDRINUSE, EADDRINUSE), /* 98 Address already in use */
678 MBED_DEFINE_POSIX_ERROR(EADDRNOTAVAIL, EADDRNOTAVAIL), /* 99 Cannot assign requested address */
679 MBED_DEFINE_POSIX_ERROR(ENETDOWN, ENETDOWN), /* 100 Network is down */
680 MBED_DEFINE_POSIX_ERROR(ENETUNREACH, ENETUNREACH), /* 101 Network is unreachable */
681 MBED_DEFINE_POSIX_ERROR(ENETRESET, ENETRESET), /* 102 Network dropped connection because of reset */
682 MBED_DEFINE_POSIX_ERROR(ECONNABORTED, ECONNABORTED), /* 103 Software caused connection abort */
683 MBED_DEFINE_POSIX_ERROR(ECONNRESET, ECONNRESET), /* 104 Connection reset by peer */
684 MBED_DEFINE_POSIX_ERROR(ENOBUFS, ENOBUFS), /* 105 No buffer space available */
685 MBED_DEFINE_POSIX_ERROR(EISCONN, EISCONN), /* 106 Transport endpoint is already connected */
686 MBED_DEFINE_POSIX_ERROR(ENOTCONN, ENOTCONN), /* 107 Transport endpoint is not connected */
687 MBED_DEFINE_POSIX_ERROR(ESHUTDOWN, ESHUTDOWN), /* 108 Cannot send after transport endpoint shutdown */
688 MBED_DEFINE_POSIX_ERROR(ETOOMANYREFS, ETOOMANYREFS), /* 109 Too many references: cannot splice */
689 MBED_DEFINE_POSIX_ERROR(ETIMEDOUT, ETIMEDOUT), /* 110 Connection timed out */
690 MBED_DEFINE_POSIX_ERROR(ECONNREFUSED, ECONNREFUSED), /* 111 Connection refused */
691 MBED_DEFINE_POSIX_ERROR(EHOSTDOWN, EHOSTDOWN), /* 112 Host is down */
692 MBED_DEFINE_POSIX_ERROR(EHOSTUNREACH, EHOSTUNREACH), /* 113 No route to host */
693 MBED_DEFINE_POSIX_ERROR(EALREADY, EALREADY), /* 114 Operation already in progress */
694 MBED_DEFINE_POSIX_ERROR(EINPROGRESS, EINPROGRESS), /* 115 Operation now in progress */
695 MBED_DEFINE_POSIX_ERROR(ESTALE, ESTALE), /* 116 Stale NFS file handle */
696 MBED_DEFINE_POSIX_ERROR(EUCLEAN, EUCLEAN), /* 117 Structure needs cleaning */
697 MBED_DEFINE_POSIX_ERROR(ENOTNAM, ENOTNAM), /* 118 Not a XENIX named type file */
698 MBED_DEFINE_POSIX_ERROR(ENAVAIL, ENAVAIL), /* 119 No XENIX semaphores available */
699 MBED_DEFINE_POSIX_ERROR(EISNAM, EISNAM), /* 120 Is a named type file */
700 MBED_DEFINE_POSIX_ERROR(EREMOTEIO, EREMOTEIO), /* 121 Remote I/O error */
701 MBED_DEFINE_POSIX_ERROR(EDQUOT, EDQUOT), /* 122 Quota exceeded */
702 MBED_DEFINE_POSIX_ERROR(ENOMEDIUM, ENOMEDIUM), /* 123 No medium found */
703 MBED_DEFINE_POSIX_ERROR(EMEDIUMTYPE, EMEDIUMTYPE), /* 124 Wrong medium type */
704 MBED_DEFINE_POSIX_ERROR(ECANCELED, ECANCELED), /* 125 Operation Canceled */
705 MBED_DEFINE_POSIX_ERROR(ENOKEY, ENOKEY), /* 126 Required key not available */
706 MBED_DEFINE_POSIX_ERROR(EKEYEXPIRED, EKEYEXPIRED), /* 127 Key has expired */
707 MBED_DEFINE_POSIX_ERROR(EKEYREVOKED, EKEYREVOKED), /* 128 Key has been revoked */
708 MBED_DEFINE_POSIX_ERROR(EKEYREJECTED, EKEYREJECTED), /* 129 Key was rejected by service */
709 MBED_DEFINE_POSIX_ERROR(EOWNERDEAD, EOWNERDEAD), /* 130 Owner died */
710 MBED_DEFINE_POSIX_ERROR(ENOTRECOVERABLE, ENOTRECOVERABLE), /* 131 State not recoverable */
711
712 //Below are MBED SYSTEM ERROR CODE definitions
713 //MBED SYSTEM ERROR CODE definitions starts at offset MBED_SYSTEM_ERROR_BASE, see above.
714 // Error Name Error Offset Error Code
715 MBED_DEFINE_SYSTEM_ERROR(UNKNOWN, 0), /* 256 Unknown error */
716 MBED_DEFINE_SYSTEM_ERROR(INVALID_ARGUMENT, 1), /* 257 Invalid Argument */
717 MBED_DEFINE_SYSTEM_ERROR(INVALID_DATA_DETECTED, 2), /* 258 Invalid data detected */
718 MBED_DEFINE_SYSTEM_ERROR(INVALID_FORMAT, 3), /* 259 Invalid format */
719 MBED_DEFINE_SYSTEM_ERROR(INVALID_INDEX, 4), /* 260 Invalid Index */
720 MBED_DEFINE_SYSTEM_ERROR(INVALID_SIZE, 5), /* 261 Inavlid Size */
721 MBED_DEFINE_SYSTEM_ERROR(INVALID_OPERATION, 6), /* 262 Invalid Operation */
722 MBED_DEFINE_SYSTEM_ERROR(ITEM_NOT_FOUND, 7), /* 263 Item Not Found */
723 MBED_DEFINE_SYSTEM_ERROR(ACCESS_DENIED, 8), /* 264 Access Denied */
724 MBED_DEFINE_SYSTEM_ERROR(UNSUPPORTED, 9), /* 265 Unsupported */
725 MBED_DEFINE_SYSTEM_ERROR(BUFFER_FULL, 10), /* 266 Buffer Full */
726 MBED_DEFINE_SYSTEM_ERROR(MEDIA_FULL, 11), /* 267 Media/Disk Full */
727 MBED_DEFINE_SYSTEM_ERROR(ALREADY_IN_USE, 12), /* 268 Already in use */
728 MBED_DEFINE_SYSTEM_ERROR(TIME_OUT, 13), /* 269 Timeout error */
729 MBED_DEFINE_SYSTEM_ERROR(NOT_READY, 14), /* 270 Not Ready */
730 MBED_DEFINE_SYSTEM_ERROR(FAILED_OPERATION, 15), /* 271 Requested Operation failed */
731 MBED_DEFINE_SYSTEM_ERROR(OPERATION_PROHIBITED, 16), /* 272 Operation prohibited */
732 MBED_DEFINE_SYSTEM_ERROR(OPERATION_ABORTED, 17), /* 273 Operation failed */
733 MBED_DEFINE_SYSTEM_ERROR(WRITE_PROTECTED, 18), /* 274 Attempt to write to write-protected resource */
734 MBED_DEFINE_SYSTEM_ERROR(NO_RESPONSE, 19), /* 275 No response */
735 MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_LOCK_FAILED, 20), /* 276 Sempahore lock failed */
736 MBED_DEFINE_SYSTEM_ERROR(MUTEX_LOCK_FAILED, 21), /* 277 Mutex lock failed */
737 MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_UNLOCK_FAILED, 22), /* 278 Sempahore unlock failed */
738 MBED_DEFINE_SYSTEM_ERROR(MUTEX_UNLOCK_FAILED, 23), /* 279 Mutex unlock failed */
739 MBED_DEFINE_SYSTEM_ERROR(CRC_ERROR, 24), /* 280 CRC error or mismatch */
740 MBED_DEFINE_SYSTEM_ERROR(OPEN_FAILED, 25), /* 281 Open failed */
741 MBED_DEFINE_SYSTEM_ERROR(CLOSE_FAILED, 26), /* 282 Close failed */
742 MBED_DEFINE_SYSTEM_ERROR(READ_FAILED, 27), /* 283 Read failed */
743 MBED_DEFINE_SYSTEM_ERROR(WRITE_FAILED, 28), /* 284 Write failed */
744 MBED_DEFINE_SYSTEM_ERROR(INITIALIZATION_FAILED, 29), /* 285 Initialization failed */
745 MBED_DEFINE_SYSTEM_ERROR(BOOT_FAILURE, 30), /* 286 Boot failure */
746 MBED_DEFINE_SYSTEM_ERROR(OUT_OF_MEMORY, 31), /* 287 Out of memory */
747 MBED_DEFINE_SYSTEM_ERROR(OUT_OF_RESOURCES, 32), /* 288 Out of resources */
748 MBED_DEFINE_SYSTEM_ERROR(ALLOC_FAILED, 33), /* 289 Alloc failed */
749 MBED_DEFINE_SYSTEM_ERROR(FREE_FAILED, 34), /* 290 Free failed */
750 MBED_DEFINE_SYSTEM_ERROR(OVERFLOW, 35), /* 291 Overflow error */
751 MBED_DEFINE_SYSTEM_ERROR(UNDERFLOW, 36), /* 292 Underflow error */
752 MBED_DEFINE_SYSTEM_ERROR(STACK_OVERFLOW, 37), /* 293 Stack overflow error */
753 MBED_DEFINE_SYSTEM_ERROR(ISR_QUEUE_OVERFLOW, 38), /* 294 ISR queue overflow */
754 MBED_DEFINE_SYSTEM_ERROR(TIMER_QUEUE_OVERFLOW, 39), /* 295 Timer Queue overflow */
755 MBED_DEFINE_SYSTEM_ERROR(CLIB_SPACE_UNAVAILABLE, 40), /* 296 Standard library error - Space unavailable */
756 MBED_DEFINE_SYSTEM_ERROR(CLIB_EXCEPTION, 41), /* 297 Standard library error - Exception */
757 MBED_DEFINE_SYSTEM_ERROR(CLIB_MUTEX_INIT_FAILURE, 42), /* 298 Standard library error - Mutex Init failure */
758 MBED_DEFINE_SYSTEM_ERROR(CREATE_FAILED, 43), /* 299 Create failed */
759 MBED_DEFINE_SYSTEM_ERROR(DELETE_FAILED, 44), /* 300 Delete failed */
760 MBED_DEFINE_SYSTEM_ERROR(THREAD_CREATE_FAILED, 45), /* 301 Thread Create failed */
761 MBED_DEFINE_SYSTEM_ERROR(THREAD_DELETE_FAILED, 46), /* 302 Thread Delete failed */
762 MBED_DEFINE_SYSTEM_ERROR(PROHIBITED_IN_ISR_CONTEXT, 47), /* 303 Operation Prohibited in ISR context */
763 MBED_DEFINE_SYSTEM_ERROR(PINMAP_INVALID, 48), /* 304 Pinmap Invalid */
764 MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT, 49), /* 305 Unknown Rtos Error */
765 MBED_DEFINE_SYSTEM_ERROR(RTOS_THREAD_EVENT, 50), /* 306 Rtos Thread Error */
766 MBED_DEFINE_SYSTEM_ERROR(RTOS_MUTEX_EVENT, 51), /* 307 Rtos Mutex Error */
767 MBED_DEFINE_SYSTEM_ERROR(RTOS_SEMAPHORE_EVENT, 52), /* 308 Rtos Semaphore Error */
768 MBED_DEFINE_SYSTEM_ERROR(RTOS_MEMORY_POOL_EVENT, 53), /* 309 Rtos Memory Pool Error */
769 MBED_DEFINE_SYSTEM_ERROR(RTOS_TIMER_EVENT, 54), /* 310 Rtos Timer Error */
770 MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT_FLAGS_EVENT, 55), /* 311 Rtos Event flags Error */
771 MBED_DEFINE_SYSTEM_ERROR(RTOS_MESSAGE_QUEUE_EVENT, 56), /* 312 Rtos Message queue Error */
772 MBED_DEFINE_SYSTEM_ERROR(DEVICE_BUSY, 57), /* 313 Device Busy */
773 MBED_DEFINE_SYSTEM_ERROR(CONFIG_UNSUPPORTED, 58), /* 314 Configuration not supported */
774 MBED_DEFINE_SYSTEM_ERROR(CONFIG_MISMATCH, 59), /* 315 Configuration mismatch */
775 MBED_DEFINE_SYSTEM_ERROR(ALREADY_INITIALIZED, 60), /* 316 Already initialzied */
776 MBED_DEFINE_SYSTEM_ERROR(HARDFAULT_EXCEPTION, 61), /* 317 HardFault exception */
777 MBED_DEFINE_SYSTEM_ERROR(MEMMANAGE_EXCEPTION, 62), /* 318 MemManage exception */
778 MBED_DEFINE_SYSTEM_ERROR(BUSFAULT_EXCEPTION, 63), /* 319 BusFault exception */
779 MBED_DEFINE_SYSTEM_ERROR(USAGEFAULT_EXCEPTION, 64), /* 320 UsageFault exception*/
780 MBED_DEFINE_SYSTEM_ERROR(BLE_NO_FRAME_INITIALIZED, 65), /* 321 BLE No frame initialized */
781 MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_CREATION_FAILED, 66), /* 322 BLE Backend creation failed */
782 MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_NOT_INITIALIZED, 67), /* 323 BLE Backend not initialized */
783
784 //Everytime you add a new system error code, you must update
785 //Error documentation under Handbook to capture the info on
786 //the new error status/codes
787
788 //MBED CUSTOM ERROR CODE definitions starts at offset MBED_CUSTOM_ERROR_BASE, see above.
789 /* Add More/Custom Error Codes here, See example below */
790 //DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR , 1 ),
791
792} mbed_error_code_t;
793
794/** mbed_error_ctx struct
795 *
796 * This struct captures the context information at the time of error.\n
797 * It primarily contains information about the thread where the error originated,\n
798 * filename/line number of the source file where the error occurred, a context specific error value(error_value)\n
799 * and the address where the error originated.\n
800 *
801 * @note
802 * Below are the members of mbed_error_ctx struct\n
803 * error_status mbed_error_status_t value for this error\n
804 * error_function_address Address where the error occurred\n
805 * thread_id ID of the thread which generated the error\n
806 * thread_entry_address Entry function of the thread which generated the error\n
807 * thread_stack_size Stack Size of the thread which generated the error\n
808 * thread_stack_mem Stack Top of the thread which generated the error\n
809 * thread_current_sp Current Stack Pointer of the thread which generated the error\n
810 * error_value A context/error specific value associated with this error\n
811 * error_filename Filename where the error originated\n
812 * error_line_number Line number in error_filename where the error originated\n
813 */
814typedef struct _mbed_error_ctx {
815 mbed_error_status_t error_status;
816 uint32_t error_address;
817 uint32_t error_value;
818 uint32_t thread_id;
819 uint32_t thread_entry_address;
820 uint32_t thread_stack_size;
821 uint32_t thread_stack_mem;
822 uint32_t thread_current_sp;
823#ifdef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
824 char error_filename[MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN];
825 uint32_t error_line_number;
826#endif
827} mbed_error_ctx;
828
829/** To generate a fatal compile-time error, you can use the pre-processor #error directive.
830 *
831 * @param format C string that contains data stream to be printed.
832 * Code snippets below show valid format.
833 *
834 * @code
835 * #error "That shouldn't have happened!"
836 * @endcode
837 *
838 * If the compiler evaluates this line, it will report the error and stop the compile.
839 *
840 * For example, you could use this to check some user-defined compile-time variables:
841 *
842 * @code
843 * #define NUM_PORTS 7
844 * #if (NUM_PORTS > 4)
845 * #error "NUM_PORTS must be less than 4"
846 * #endif
847 * @endcode
848 *
849 * Reporting Run-Time Errors:
850 * To generate a fatal run-time error, you can use the mbed error() function.
851 *
852 * @code
853 * error("That shouldn't have happened!");
854 * @endcode
855 *
856 * If the mbed running the program executes this function, it will print the
857 * message via the USB serial port, and then die with the blue lights of death!
858 *
859 * The message can use printf-style formatting, so you can report variables in the
860 * message too. For example, you could use this to check a run-time condition:
861 *
862 * @code
863 * if(x >= 5) {
864 * error("expected x to be less than 5, but got %d", x);
865 * }
866 * @endcode
867 *
868 *
869 */
870
871void error(const char *format, ...);
872
873/**
874 * Call this Macro to generate a mbed_error_status_t value for a System error
875 * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
876 * @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.
877 *
878 * @code
879 *
880 * mbed_error_status_t driver_error = MBED_MAKE_SYSTEM_ERROR( MODULE_DRIVER_USB, MBED_ERROR_CODE_INITIALIZATION_FAILED )
881 *
882 * @endcode
883 * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
884 *
885 */
886#define MBED_MAKE_SYSTEM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, module, error_code)
887
888/**
889 * Call this Macro to generate a mbed_error_status_t value for a Custom error
890 * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
891 * @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.
892 *
893 * @code
894 *
895 * mbed_error_status_t custom_error = MBED_MAKE_CUSTOM_ERROR( MBED_MODULE_APPLICATION, 0xDEAD//16-bit custom error code )
896 *
897 * @endcode
898 * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_CUSTOM
899 *
900 */
901#define MBED_MAKE_CUSTOM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, module, error_code)
902
903/**
904 * Call this Macro to generate a mbed_error_status_t value for a System error
905 * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
906 * @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.
907 *
908 * @code
909 *
910 * mbed_error_status_t new_error = MBED_MAKE_ERROR( MODULE_DRIVER_USB, MBED_ERROR_INITIALIZATION_FAILED )
911 *
912 * @endcode
913 * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
914 *
915 */
916#define MBED_MAKE_ERROR(module, error_code) MBED_MAKE_SYSTEM_ERROR(module, error_code)
917
918/**
919 * Callback/Error hook function prototype. Applications needing a callback when an error is reported can use mbed_set_error_hook function
920 * to register a callback/error hook function using the following prototype. When an error happens in the system error handling
921 * implementation will invoke this callback with the mbed_error_status_t reported and the error context at the time of error.
922 * @param error_status mbed_error_status_t status being reported.
923 * @param error_ctx Error context structure associated with this error.
924 * @return void
925 *
926 */
927typedef void (*mbed_error_hook_t)(const mbed_error_ctx *error_ctx);
928
929/**
930 * Call this function to set a system error/warning. This function will log the error status with the context info and return to caller.
931 *
932 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
933 * @param error_msg The error message to be printed out to STDIO/Serial.
934 * @param error_value Value associated with the error status. This would depend on error code/error scenario.
935 * @param filename Name of the source file originating the error( Most callers can pass __FILE__ here ).
936 * @param line_number The line number of the source file originating the error( Most callers can pass __LINE__ here ) .
937 * @return 0 or MBED_SUCCESS.
938 * MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
939 *
940 * @code
941 *
942 * mbed_error( ERROR_OUT_OF_MEMORY, "Out of memory error", 0, __FILE__, __LINE__ )
943 *
944 * @endcode
945 *
946 * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API
947 */
948mbed_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);
949
950/**
951 * Returns the first system error reported.
952 * @return mbed_error_status_t code logged for the first error or MBED_SUCCESS if no errors are logged.
953 *
954 */
955mbed_error_status_t mbed_get_first_error(void);
956
957/**
958 * Returns the most recent system error reported.
959 * @return mbed_error_status_t code logged for the last error or MBED_SUCCESS if no errors are logged.
960 *
961 */
962mbed_error_status_t mbed_get_last_error(void);
963
964/**
965 * Returns the number of system errors reported after boot.
966 * @return int Number of errors reported.
967 *
968 */
969int mbed_get_error_count(void);
970
971/**
972 * 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.
973 *
974 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
975 * @param error_msg The error message to be printed out to STDIO/Serial.
976 * @param error_value Value associated with the error status. This would depend on error code/error scenario.
977 * @param filename Name of the source file originating the error( Most callers can pass __FILE__ here ).
978 * @param line_number The line number of the source file originating the error( Most callers can pass __LINE__ here ) .
979 * @return 0 or MBED_SUCCESS.
980 * MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
981 *
982 * @code
983 *
984 * mbed_error( MBED_ERROR_PROHIBITED_OPERATION, "Prohibited operation tried", 0, __FILE__, __LINE__ )
985 *
986 * @endcode
987 *
988 * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API
989 */
990mbed_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);
991
992/**
993 * Registers an application defined error callback with the error handling system.
994 * This function will be called with error context info whenever system handles a mbed_error/mbed_warning call
995 * NOTE: This function should be implemented for re-entrancy as multiple threads may invoke mbed_error which may cause error hook to be called.
996 * @param custom_error_hook mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
997 * @return 0 or MBED_SUCCESS on success.
998 * MBED_ERROR_INVALID_ARGUMENT in case of NULL for custom_error_hook
999 *
1000 * @code
1001 *
1002 * mbed_error_status_t my_custom_error_hook(mbed_error_status_t error_status, const mbed_error_ctx *error_ctx) {
1003 * //Do something with the error_status or error_ctx
1004 * }
1005 *
1006 * mbed_set_error_hook( my_custom_error_hook )
1007 *
1008 * @endcode
1009 * @note The erro hook function implementation should be re-entrant.
1010 *
1011 */
1012mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t custom_error_hook);
1013
1014/**
1015 * Reads the first error context information captured.
1016 * @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.
1017 * @return 0 or MBED_SUCCESS on success.
1018 * MBED_ERROR_INVALID_ARGUMENT in case of invalid index
1019 *
1020 */
1021mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info);
1022
1023/**
1024 * Reads the last error context information captured.
1025 * @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.
1026 * @return 0 or MBED_ERROR_SUCCESS on success.
1027 * MBED_ERROR_INVALID_ARGUMENT in case of invalid index
1028 *
1029 */
1030mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info);
1031
1032/**
1033 * Clears the last error, first error, error count and all entries in the error history.
1034 * @return 0 or MBED_SUCCESS on success.
1035 *
1036 */
1037mbed_error_status_t mbed_clear_all_errors(void);
1038
1039/**
1040 * Generates a mbed_error_status_t value based on passed in values for type, module and error code.
1041 * @param error_type Error type based on mbed_error_type_t enum.
1042 * @param module Module type based on mbed_module_type_t enum.
1043 * @param error_code Error codes defined by mbed_error_code_t enum
1044 * @return 0 or MBED_ERROR_SUCCESS on success.
1045 *
1046 */
1047mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code);
1048
1049/**
1050 * 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.
1051 * @return Current number of entries in the error history.
1052 *
1053 */
1054int mbed_get_error_hist_count(void);
1055
1056/**
1057 * Reads the error context information for a specific error from error history, specified by the index.
1058 *
1059 * @param index index of the error context entry in the history to be retrieved.\n
1060 * The number of entries in the error history is configured during build and the max index depends on max depth of error history.\n
1061 * 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
1062 * @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.
1063 * @return 0 or MBED_SUCCESS on success.
1064 * MBED_ERROR_INVALID_ARGUMENT in case of invalid index
1065 *
1066 */
1067mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info);
1068
1069/**
1070 * Saves the error history information to a file
1071 *
1072 * @param path path to the file in the filesystem
1073 * @return 0 or MBED_ERROR_SUCCESS on success.
1074 * MBED_ERROR_WRITE_FAILED if writing to file failed
1075 * MBED_ERROR_INVALID_ARGUMENT if path is not valid
1076 *
1077 * @note Filesystem support is required in order for this function to work.
1078 *
1079 */
1080mbed_error_status_t mbed_save_error_hist(const char *path);
1081
1082#ifdef __cplusplus
1083}
1084#endif
1085
1086#endif
1087
1088/** @}*/
1089/** @}*/
1090
1091
Note: See TracBrowser for help on using the repository browser.