1 /* 2 * Copyright (c) 2006-2018, RT-Thread Development Team 3 * 4 * SPDX-License-Identifier: Apache-2.0 5 * 6 * Change Logs: 7 * Date Author Notes 8 * 2006-03-18 Bernard the first version 9 * 2006-04-26 Bernard add semaphore APIs 10 * 2006-08-10 Bernard add version information 11 * 2007-01-28 Bernard rename RT_OBJECT_Class_Static to RT_Object_Class_Static 12 * 2007-03-03 Bernard clean up the definitions to rtdef.h 13 * 2010-04-11 yi.qiu add module feature 14 * 2013-06-24 Bernard add rt_kprintf re-define when not use RT_USING_CONSOLE. 15 * 2016-08-09 ArdaFu add new thread and interrupt hook. 16 * 2018-11-22 Jesven add all cpu's lock and ipi handler 17 */ 18 19 #ifndef __RT_THREAD_H__ 20 #define __RT_THREAD_H__ 21 22 #include <rtconfig.h> 23 #include <rtdebug.h> 24 #include <rtdef.h> 25 #include <rtservice.h> 26 #include <rtm.h> 27 28 #ifdef __cplusplus 29 extern "C" { 30 #endif 31 32 /** 33 * @addtogroup KernelObject 34 */ 35 36 /**@{*/ 37 38 /* 39 * kernel object interface 40 */ 41 void rt_system_object_init(void); 42 struct rt_object_information * 43 rt_object_get_information(enum rt_object_class_type type); 44 void rt_object_init(struct rt_object *object, 45 enum rt_object_class_type type, 46 const char *name); 47 void rt_object_detach(rt_object_t object); 48 rt_object_t rt_object_allocate(enum rt_object_class_type type, 49 const char *name); 50 void rt_object_delete(rt_object_t object); 51 rt_bool_t rt_object_is_systemobject(rt_object_t object); 52 rt_uint8_t rt_object_get_type(rt_object_t object); 53 rt_object_t rt_object_find(const char *name, rt_uint8_t type); 54 55 #ifdef RT_USING_HOOK 56 void rt_object_attach_sethook(void (*hook)(struct rt_object *object)); 57 void rt_object_detach_sethook(void (*hook)(struct rt_object *object)); 58 void rt_object_trytake_sethook(void (*hook)(struct rt_object *object)); 59 void rt_object_take_sethook(void (*hook)(struct rt_object *object)); 60 void rt_object_put_sethook(void (*hook)(struct rt_object *object)); 61 #endif 62 63 /**@}*/ 64 65 /** 66 * @addtogroup Clock 67 */ 68 69 /**@{*/ 70 71 /* 72 * clock & timer interface 73 */ 74 void rt_system_tick_init(void); 75 rt_tick_t rt_tick_get(void); 76 void rt_tick_set(rt_tick_t tick); 77 void rt_tick_increase(void); 78 int rt_tick_from_millisecond(rt_int32_t ms); 79 80 void rt_system_timer_init(void); 81 void rt_system_timer_thread_init(void); 82 83 void rt_timer_init(rt_timer_t timer, 84 const char *name, 85 void (*timeout)(void *parameter), 86 void *parameter, 87 rt_tick_t time, 88 rt_uint8_t flag); 89 rt_err_t rt_timer_detach(rt_timer_t timer); 90 rt_timer_t rt_timer_create(const char *name, 91 void (*timeout)(void *parameter), 92 void *parameter, 93 rt_tick_t time, 94 rt_uint8_t flag); 95 rt_err_t rt_timer_delete(rt_timer_t timer); 96 rt_err_t rt_timer_start(rt_timer_t timer); 97 rt_err_t rt_timer_stop(rt_timer_t timer); 98 rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg); 99 100 rt_tick_t rt_timer_next_timeout_tick(void); 101 void rt_timer_check(void); 102 103 #ifdef RT_USING_HOOK 104 void rt_timer_enter_sethook(void (*hook)(struct rt_timer *timer)); 105 void rt_timer_exit_sethook(void (*hook)(struct rt_timer *timer)); 106 #endif 107 108 /**@}*/ 109 110 /** 111 * @addtogroup Thread 112 */ 113 114 /**@{*/ 115 116 /* 117 * thread interface 118 */ 119 rt_err_t rt_thread_init(struct rt_thread *thread, 120 const char *name, 121 void (*entry)(void *parameter), 122 void *parameter, 123 void *stack_start, 124 rt_uint32_t stack_size, 125 rt_uint8_t priority, 126 rt_uint32_t tick); 127 rt_err_t rt_thread_detach(rt_thread_t thread); 128 rt_thread_t rt_thread_create(const char *name, 129 void (*entry)(void *parameter), 130 void *parameter, 131 rt_uint32_t stack_size, 132 rt_uint8_t priority, 133 rt_uint32_t tick); 134 rt_thread_t rt_thread_self(void); 135 rt_thread_t rt_thread_find(char *name); 136 rt_err_t rt_thread_startup(rt_thread_t thread); 137 rt_err_t rt_thread_delete(rt_thread_t thread); 138 139 rt_err_t rt_thread_yield(void); 140 rt_err_t rt_thread_delay(rt_tick_t tick); 141 rt_err_t rt_thread_mdelay(rt_int32_t ms); 142 rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg); 143 rt_err_t rt_thread_suspend(rt_thread_t thread); 144 rt_err_t rt_thread_resume(rt_thread_t thread); 145 void rt_thread_timeout(void *parameter); 146 147 #ifdef RT_USING_SIGNALS 148 void rt_thread_alloc_sig(rt_thread_t tid); 149 void rt_thread_free_sig(rt_thread_t tid); 150 int rt_thread_kill(rt_thread_t tid, int sig); 151 #endif 152 153 #ifdef RT_USING_HOOK 154 void rt_thread_suspend_sethook(void (*hook)(rt_thread_t thread)); 155 void rt_thread_resume_sethook (void (*hook)(rt_thread_t thread)); 156 void rt_thread_inited_sethook (void (*hook)(rt_thread_t thread)); 157 #endif 158 159 /* 160 * idle thread interface 161 */ 162 void rt_thread_idle_init(void); 163 #if defined(RT_USING_HOOK) || defined(RT_USING_IDLE_HOOK) 164 rt_err_t rt_thread_idle_sethook(void (*hook)(void)); 165 rt_err_t rt_thread_idle_delhook(void (*hook)(void)); 166 #endif 167 void rt_thread_idle_excute(void); 168 rt_thread_t rt_thread_idle_gethandler(void); 169 170 /* 171 * schedule service 172 */ 173 void rt_system_scheduler_init(void); 174 void rt_system_scheduler_start(void); 175 176 void rt_schedule(void); 177 void rt_schedule_insert_thread(struct rt_thread *thread); 178 void rt_schedule_remove_thread(struct rt_thread *thread); 179 180 void rt_enter_critical(void); 181 void rt_exit_critical(void); 182 rt_uint16_t rt_critical_level(void); 183 184 #ifdef RT_USING_HOOK 185 void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to)); 186 #endif 187 188 #ifdef RT_USING_SMP 189 void rt_scheduler_ipi_handler(int vector, void *param); 190 #endif 191 192 /**@}*/ 193 194 /** 195 * @addtogroup Signals 196 * @{ 197 */ 198 #ifdef RT_USING_SIGNALS 199 void rt_signal_mask(int signo); 200 void rt_signal_unmask(int signo); 201 rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler); 202 int rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout); 203 204 int rt_system_signal_init(void); 205 #endif 206 /*@}*/ 207 208 /** 209 * @addtogroup MM 210 */ 211 212 /**@{*/ 213 214 /* 215 * memory management interface 216 */ 217 #ifdef RT_USING_MEMPOOL 218 /* 219 * memory pool interface 220 */ 221 rt_err_t rt_mp_init(struct rt_mempool *mp, 222 const char *name, 223 void *start, 224 rt_size_t size, 225 rt_size_t block_size); 226 rt_err_t rt_mp_detach(struct rt_mempool *mp); 227 rt_mp_t rt_mp_create(const char *name, 228 rt_size_t block_count, 229 rt_size_t block_size); 230 rt_err_t rt_mp_delete(rt_mp_t mp); 231 232 void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time); 233 void rt_mp_free(void *block); 234 235 #ifdef RT_USING_HOOK 236 void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block)); 237 void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block)); 238 #endif 239 240 #endif 241 242 #ifdef RT_USING_HEAP 243 /* 244 * heap memory interface 245 */ 246 void rt_system_heap_init(void *begin_addr, void *end_addr); 247 248 void *rt_malloc(rt_size_t nbytes); 249 void rt_free(void *ptr); 250 void *rt_realloc(void *ptr, rt_size_t nbytes); 251 void *rt_calloc(rt_size_t count, rt_size_t size); 252 void *rt_malloc_align(rt_size_t size, rt_size_t align); 253 void rt_free_align(void *ptr); 254 255 void rt_memory_info(rt_uint32_t *total, 256 rt_uint32_t *used, 257 rt_uint32_t *max_used); 258 259 #ifdef RT_USING_SLAB 260 void *rt_page_alloc(rt_size_t npages); 261 void rt_page_free(void *addr, rt_size_t npages); 262 #endif 263 264 #ifdef RT_USING_HOOK 265 void rt_malloc_sethook(void (*hook)(void *ptr, rt_size_t size)); 266 void rt_free_sethook(void (*hook)(void *ptr)); 267 #endif 268 269 #endif 270 271 #ifdef RT_USING_MEMHEAP 272 /** 273 * memory heap object interface 274 */ 275 rt_err_t rt_memheap_init(struct rt_memheap *memheap, 276 const char *name, 277 void *start_addr, 278 rt_size_t size); 279 rt_err_t rt_memheap_detach(struct rt_memheap *heap); 280 void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size); 281 void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize); 282 void rt_memheap_free(void *ptr); 283 #endif 284 285 /**@}*/ 286 287 /** 288 * @addtogroup IPC 289 */ 290 291 /**@{*/ 292 293 #ifdef RT_USING_SEMAPHORE 294 /* 295 * semaphore interface 296 */ 297 rt_err_t rt_sem_init(rt_sem_t sem, 298 const char *name, 299 rt_uint32_t value, 300 rt_uint8_t flag); 301 rt_err_t rt_sem_detach(rt_sem_t sem); 302 rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag); 303 rt_err_t rt_sem_delete(rt_sem_t sem); 304 305 rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time); 306 rt_err_t rt_sem_trytake(rt_sem_t sem); 307 rt_err_t rt_sem_release(rt_sem_t sem); 308 rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg); 309 #endif 310 311 #ifdef RT_USING_MUTEX 312 /* 313 * mutex interface 314 */ 315 rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag); 316 rt_err_t rt_mutex_detach(rt_mutex_t mutex); 317 rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag); 318 rt_err_t rt_mutex_delete(rt_mutex_t mutex); 319 320 rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time); 321 rt_err_t rt_mutex_release(rt_mutex_t mutex); 322 rt_err_t rt_mutex_control(rt_mutex_t mutex, int cmd, void *arg); 323 #endif 324 325 #ifdef RT_USING_EVENT 326 /* 327 * event interface 328 */ 329 rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag); 330 rt_err_t rt_event_detach(rt_event_t event); 331 rt_event_t rt_event_create(const char *name, rt_uint8_t flag); 332 rt_err_t rt_event_delete(rt_event_t event); 333 334 rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set); 335 rt_err_t rt_event_recv(rt_event_t event, 336 rt_uint32_t set, 337 rt_uint8_t opt, 338 rt_int32_t timeout, 339 rt_uint32_t *recved); 340 rt_err_t rt_event_control(rt_event_t event, int cmd, void *arg); 341 #endif 342 343 #ifdef RT_USING_MAILBOX 344 /* 345 * mailbox interface 346 */ 347 rt_err_t rt_mb_init(rt_mailbox_t mb, 348 const char *name, 349 void *msgpool, 350 rt_size_t size, 351 rt_uint8_t flag); 352 rt_err_t rt_mb_detach(rt_mailbox_t mb); 353 rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag); 354 rt_err_t rt_mb_delete(rt_mailbox_t mb); 355 356 rt_err_t rt_mb_send(rt_mailbox_t mb, rt_ubase_t value); 357 rt_err_t rt_mb_send_wait(rt_mailbox_t mb, 358 rt_ubase_t value, 359 rt_int32_t timeout); 360 rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout); 361 rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg); 362 #endif 363 364 #ifdef RT_USING_MESSAGEQUEUE 365 /* 366 * message queue interface 367 */ 368 rt_err_t rt_mq_init(rt_mq_t mq, 369 const char *name, 370 void *msgpool, 371 rt_size_t msg_size, 372 rt_size_t pool_size, 373 rt_uint8_t flag); 374 rt_err_t rt_mq_detach(rt_mq_t mq); 375 rt_mq_t rt_mq_create(const char *name, 376 rt_size_t msg_size, 377 rt_size_t max_msgs, 378 rt_uint8_t flag); 379 rt_err_t rt_mq_delete(rt_mq_t mq); 380 381 rt_err_t rt_mq_send(rt_mq_t mq, void *buffer, rt_size_t size); 382 rt_err_t rt_mq_urgent(rt_mq_t mq, void *buffer, rt_size_t size); 383 rt_err_t rt_mq_recv(rt_mq_t mq, 384 void *buffer, 385 rt_size_t size, 386 rt_int32_t timeout); 387 rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg); 388 #endif 389 390 /**@}*/ 391 392 #ifdef RT_USING_DEVICE 393 /** 394 * @addtogroup Device 395 */ 396 397 /**@{*/ 398 399 /* 400 * device (I/O) system interface 401 */ 402 rt_device_t rt_device_find(const char *name); 403 404 rt_err_t rt_device_register(rt_device_t dev, 405 const char *name, 406 rt_uint16_t flags); 407 rt_err_t rt_device_unregister(rt_device_t dev); 408 409 rt_device_t rt_device_create(int type, int attach_size); 410 void rt_device_destroy(rt_device_t device); 411 412 rt_err_t rt_device_init_all(void); 413 414 rt_err_t 415 rt_device_set_rx_indicate(rt_device_t dev, 416 rt_err_t (*rx_ind)(rt_device_t dev, rt_size_t size)); 417 rt_err_t 418 rt_device_set_tx_complete(rt_device_t dev, 419 rt_err_t (*tx_done)(rt_device_t dev, void *buffer)); 420 421 rt_err_t rt_device_init (rt_device_t dev); 422 rt_err_t rt_device_open (rt_device_t dev, rt_uint16_t oflag); 423 rt_err_t rt_device_close(rt_device_t dev); 424 rt_size_t rt_device_read (rt_device_t dev, 425 rt_off_t pos, 426 void *buffer, 427 rt_size_t size); 428 rt_size_t rt_device_write(rt_device_t dev, 429 rt_off_t pos, 430 const void *buffer, 431 rt_size_t size); 432 rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg); 433 434 /**@}*/ 435 #endif 436 437 /* 438 * interrupt service 439 */ 440 441 /* 442 * rt_interrupt_enter and rt_interrupt_leave only can be called by BSP 443 */ 444 void rt_interrupt_enter(void); 445 void rt_interrupt_leave(void); 446 447 #ifdef RT_USING_SMP 448 449 /* 450 * smp cpus lock service 451 */ 452 453 rt_base_t rt_cpus_lock(void); 454 void rt_cpus_unlock(rt_base_t level); 455 456 struct rt_cpu *rt_cpu_self(void); 457 struct rt_cpu *rt_cpu_index(int index); 458 459 #endif 460 461 /* 462 * the number of nested interrupts. 463 */ 464 rt_uint8_t rt_interrupt_get_nest(void); 465 466 #ifdef RT_USING_HOOK 467 void rt_interrupt_enter_sethook(void (*hook)(void)); 468 void rt_interrupt_leave_sethook(void (*hook)(void)); 469 #endif 470 471 #ifdef RT_USING_COMPONENTS_INIT 472 void rt_components_init(void); 473 void rt_components_board_init(void); 474 #endif 475 476 /** 477 * @addtogroup KernelService 478 */ 479 480 /**@{*/ 481 482 /* 483 * general kernel service 484 */ 485 #ifndef RT_USING_CONSOLE 486 #define rt_kprintf(...) 487 #define rt_kputs(str) 488 #else 489 void rt_kprintf(const char *fmt, ...); 490 void rt_kputs(const char *str); 491 #endif 492 rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr); 493 rt_int32_t rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args); 494 rt_int32_t rt_sprintf(char *buf, const char *format, ...); 495 rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...); 496 497 #if defined(RT_USING_DEVICE) && defined(RT_USING_CONSOLE) 498 rt_device_t rt_console_set_device(const char *name); 499 rt_device_t rt_console_get_device(void); 500 #endif 501 502 rt_err_t rt_get_errno(void); 503 void rt_set_errno(rt_err_t no); 504 int *_rt_errno(void); 505 #if !defined(RT_USING_NEWLIB) && !defined(_WIN32) 506 #ifndef errno 507 #define errno *_rt_errno() 508 #endif 509 #endif 510 511 int __rt_ffs(int value); 512 513 void *rt_memset(void *src, int c, rt_ubase_t n); 514 void *rt_memcpy(void *dest, const void *src, rt_ubase_t n); 515 516 rt_int32_t rt_strncmp(const char *cs, const char *ct, rt_ubase_t count); 517 rt_int32_t rt_strcmp(const char *cs, const char *ct); 518 rt_size_t rt_strlen(const char *src); 519 char *rt_strdup(const char *s); 520 #if defined(__CC_ARM) || defined(__CLANG_ARM) 521 /* leak strdup interface */ 522 char* strdup(const char* str); 523 #endif 524 525 char *rt_strstr(const char *str1, const char *str2); 526 rt_int32_t rt_sscanf(const char *buf, const char *fmt, ...); 527 char *rt_strncpy(char *dest, const char *src, rt_ubase_t n); 528 void *rt_memmove(void *dest, const void *src, rt_ubase_t n); 529 rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_ubase_t count); 530 rt_uint32_t rt_strcasecmp(const char *a, const char *b); 531 532 void rt_show_version(void); 533 534 #ifdef RT_DEBUG 535 extern void (*rt_assert_hook)(const char *ex, const char *func, rt_size_t line); 536 void rt_assert_set_hook(void (*hook)(const char *ex, const char *func, rt_size_t line)); 537 538 void rt_assert_handler(const char *ex, const char *func, rt_size_t line); 539 #endif /* RT_DEBUG */ 540 541 #ifdef RT_USING_FINSH 542 #include <finsh_api.h> 543 #endif 544 545 /**@}*/ 546 547 #ifdef __cplusplus 548 } 549 #endif 550 551 #endif 552