/* IBM_PROLOG_BEGIN_TAG */ /* This is an automatically generated prolog. */ /* */ /* $Source: src/lib/common/kernel.h $ */ /* */ /* OpenPOWER OnChipController Project */ /* */ /* Contributors Listed Below - COPYRIGHT 2015,2016 */ /* [+] International Business Machines Corp. */ /* */ /* */ /* Licensed under the Apache License, Version 2.0 (the "License"); */ /* you may not use this file except in compliance with the License. */ /* You may obtain a copy of the License at */ /* */ /* http://www.apache.org/licenses/LICENSE-2.0 */ /* */ /* Unless required by applicable law or agreed to in writing, software */ /* distributed under the License is distributed on an "AS IS" BASIS, */ /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ /* implied. See the License for the specific language governing */ /* permissions and limitations under the License. */ /* */ /* IBM_PROLOG_END_TAG */ #ifndef __KERNEL_H__ #define __KERNEL_H__ /// \file kernel.h /// \brief Kernel agnostic macros that allow the same code to work with /// different kernels. /// /// Programmers can include this instead of pk.h or ssx.h /// /// #ifndef __ASSEMBLER__ #ifdef __SSX__ /// ----------------------- Use SSX kernel interfaces -------------------------- #include "ssx.h" //Types #define KERN_SEMAPHORE SsxSemaphore #define KERN_SEMAPHORE_COUNT SsxSemaphoreCount #define KERN_DEQUE SsxDeque #define KERN_THREAD SsxThread #define KERN_THREAD_PRIORITY SsxThreadPriority #define KERN_THREAD_STATE SsxThreadState #define KERN_THREAD_ROUTINE SsxThreadRoutine #define KERN_THREAD_FLAGS SsxThreadFlags #define KERN_ADDRESS SsxAddress #define KERN_TIMER SsxTimer #define KERN_TIMER_CALLBACK SsxTimerCallback #define KERN_INTERVAL SsxInterval #define KERN_TIMEBASE SsxTimebase #define KERN_IRQ_ID SsxIrqId #define KERN_MACHINE_CONTEXT SsxMachineContext //Constants #define KERN_SEMAPHORE_PEND_TIMED_OUT SSX_SEMAPHORE_PEND_TIMED_OUT #define KERN_SEMAPHORE_PEND_NO_WAIT SSX_SEMAPHORE_PEND_NO_WAIT #define KERN_NONCRITICAL SSX_NONCRITICAL #define KERN_CRITICAL SSX_CRITICAL #define KERN_SUPERCRITICAL SSX_SUPERCRITICAL #define KERN_ERROR_CHECK_API SSX_ERROR_CHECK_API #define KERN_NO_WAIT SSX_NO_WAIT #define KERN_WAIT_FOREVER SSX_WAIT_FOREVER //Functions #define KERN_SECONDS(s) SSX_SECONDS(s) #define KERN_MILLISECONDS(m) SSX_MILLISECONDS(m) #define KERN_MICROSECONDS(u) SSX_MICROSECONDS(u) #define KERN_NANOSECONDS(n) SSX_NANOSECONDS(n) #define KERN_TIMEBASE_GET() ssx_timebase_get() #define KERN_TIMEBASE_SET(tb) ssx_timebase_set(tb) #define KERN_INTERRUPT_PREEMPTION_ENABLE() ssx_interrupt_preemption_enable() #define KERN_INTERRUPT_PREEMPTION_DISABLE() ssx_interrupt_preemption_disable() #define KERN_TIMER_CREATE(timer, callback, arg) \ ssx_timer_create(timer, callback, arg) #define KERN_TIMER_CREATE_NONPREEMPTIBLE(timer, callback, arg) \ ssx_timer_create_nonpreemptible(timer, callback, arg) #define KERN_TIMER_SCHEDULE_ABSOLUTE(timer, time, period) \ ssx_timer_schedule_absolute(timer, time, period) #define KERN_TIMER_SCHEDULE(timer, interval, period) \ ssx_timer_schedule(timer, interval, period) #define KERN_TIMER_CANCEL(timer) \ ssx_timer_cancel(timer) #define KERN_TIMER_INFO_GET(timer, timeout, active) \ ssx_timer_info_get(timer, timeout, active) #define KERN_THREAD_CREATE(thread, thread_routine, arg, stack, stack_size, priority) \ ssx_thread_create(thread, thread_routine, arg, stack, stack_size, priority) #define KERN_THREAD_INFO_GET(thread, state, priority, runnable) \ ssx_thread_info_get(thread, state, priority, runnable) #define KERN_THREAD_PRIORTY_CHANGE(thread, new_priority, old_priority) \ ssx_thread_priority_change(thread, new_priority, old_priority) #define KERN_THREAD_AT_PRIORITY(priority, thread) \ ssx_thread_at_priority(priority, thread) #define KERN_THREAD_PRIORITY_SWAP(thread_a, thread_b) \ ssx_thread_priority_swap(thread_a, thread_b) #define KERN_START_THREADS() ssx_start_threads() #define KERN_THREAD_RESUME(thread) ssx_thread_resume(thread) #define KERN_THREAD_SUSPEND(thread) ssx_thread_suspend(thread) #define KERN_THREAD_DELETE(thread) ssx_thread_delete(thread) #define KERN_COMPLETE() ssx_complete() #define KERN_SLEEP_ABSOLUTE(time) ssx_sleep_absolute(time) #define KERN_SLEEP(interval) ssx_sleep(interval) #define KERN_SEMAPHORE_CREATE(semaphore, initial_count, max_count) \ ssx_semaphore_create(semaphore, initial_count,max_count) #define KERN_SEMAPHORE_STATIC_CREATE(sem, initial_count, max_count) \ SSX_SEMAPHORE(sem, initial_count, max_count) #define KERN_SEMAPHORE_INITIALIZATION(_initial_count, _max_count) \ SSX_SEMAPHORE_INITIALIZATION(_initial_count, _max_count) #define KERN_SEMAPHORE_INFO_GET(semaphore, count, pending) \ ssx_semaphore_info_get(semaphore, count, pending) #define KERN_SEMAPHORE_POST(semaphore) \ ssx_semaphore_post(semaphore) #define KERN_SEMAPHORE_PEND(semaphore, timeout) \ ssx_semaphore_pend(semaphore, timeout) #define KERN_SEMAPHORE_RELEASE_ALL(semaphore) \ ssx_semaphore_release_all(semaphore) #define KERN_SEMAPHORE_POST_HANDLER(arg, irq, priority) \ ssx_semaphore_post_handler(arg, irq, priority) #define KERN_HALT() \ ssx_halt() #define KERN_PANIC(code) \ SSX_PANIC(code) #define KERN_DEQUE_SENTINEL_CREATE(deque) \ ssx_deque_sentinel_create(deque) #define KERN_DEQUE_SENTINEL_STATIC_CREATE(deque) \ SSX_DEQUE_SENTINEL_STATIC_CREATE(deque) #define KERN_DEQUE_SENTINEL_INIT(dq_addr) \ SSX_DEQUE_SENTINEL_INIT(dq_addr) #define KERN_DEQUE_ELEMENT_CREATE(element) \ ssx_deque_element_create(element) #define KERN_DEQUE_ELEMENT_STATIC_CREATE(deque) \ SSX_DEQUE_ELEMENT_STATIC_CREATE(deque) #define KERN_DEQUE_ELEMENT_INIT() \ SSX_DEQUE_ELEMENT_INIT() #define KERN_DEQUE_IS_EMPTY(deque) \ ssx_deque_is_empty(deque) #define KERN_DEQUE_IS_QUEUED(element) \ ssx_deque_is_queued(element) #define KERN_DEQUE_PUSH_BACK(deque, element) \ ssx_deque_push_back(deque, element) #define KERN_DEQUE_PUSH_FRONT(deque, element) \ ssx_deque_push_front(deque, element) #define KERN_DEQUE_POP_FRONT(deque) \ ssx_deque_pop_front(deque) #define KERN_DEQUE_DELETE(element) \ ssx_deque_delete(element) #define KERN_IRQ_HANDLER(f) \ SSX_IRQ_HANDLER(f) #define KERN_IRQ_SETUP(irq, polarity, trigger) \ ssx_irq_setup(irq, polarity, trigger) #define KERN_IRQ_HANDLER_SET(irq, handler, arg, priority) \ ssx_irq_handler_set(irq, handler, arg, priority) #define KERN_IRQ_ENABLE(irq) \ ssx_irq_enable(irq) #define KERN_IRQ_DISABLE(irq) \ ssx_irq_disable(irq) #define KERN_IRQ_STATUS_CLEAR(irq) \ ssx_irq_status_clear(irq) #define KERN_IRQ_STATUS_SET(irq, value) \ ssx_irq_status_set(irq, value) #define KERN_IRQ_FAST2FULL(fast_handler, full_handler) \ SSX_IRQ_FAST2FULL(fast_handler, full_handler) #define KERN_CRITICAL_SECTION_ENTER(priority, pctx) \ ssx_critical_section_enter(priority, pctx) #define KERN_CRITICAL_SECTION_EXIT(pctx) \ ssx_critical_section_exit(pctx) #define KERN_CONTEXT_CRITICAL_INTERRUPT() \ __ssx_kernel_context_critical_interrupt() #define KERN_ERROR_IF(condition, code) SSX_ERROR_IF(condition, code) #define KERN_CAST_POINTER(t, p) SSX_CAST_POINTER(t, p) #define KERN_STATIC_ASSERT(cond) SSX_STATIC_ASSERT(cond) #elif defined(__PK__) /// ----------------------- Use PK kernel interfaces -------------------------- #include "pk.h" //Types #define KERN_SEMAPHORE PkSemaphore #define KERN_SEMAPHORE_COUNT PkSemaphoreCount #define KERN_DEQUE PkDeque #define KERN_THREAD PkThread #define KERN_THREAD_PRIORITY PkThreadPriority #define KERN_THREAD_STATE PkThreadState #define KERN_THREAD_ROUTINE PkThreadRoutine #define KERN_THREAD_FLAGS PkThreadFlags #define KERN_ADDRESS PkAddress #define KERN_TIMER PkTimer #define KERN_TIMER_CALLBACK PkTimerCallback #define KERN_INTERVAL PkInterval #define KERN_TIMEBASE PkTimebase #define KERN_IRQ_ID PkIrqId #define KERN_MACHINE_CONTEXT PkMachineContext //Constants #define KERN_SEMAPHORE_PEND_TIMED_OUT PK_SEMAPHORE_PEND_TIMED_OUT #define KERN_SEMAPHORE_PEND_NO_WAIT PK_SEMAPHORE_PEND_NO_WAIT #define KERN_NONCRITICAL 0 #define KERN_CRITICAL 0 #define KERN_SUPERCRITICAL 0 #define KERN_ERROR_CHECK_API PK_ERROR_CHECK_API #define KERN_NO_WAIT PK_NO_WAIT #define KERN_WAIT_FOREVER PK_WAIT_FOREVER //Functions #define KERN_SECONDS(s) PK_SECONDS(s) #define KERN_MILLISECONDS(m) PK_MILLISECONDS(m) #define KERN_MICROSECONDS(u) PK_MICROSECONDS(u) #define KERN_NANOSECONDS(n) PK_NANOSECONDS(n) #define KERN_TIMEBASE_GET() pk_timebase_get() #define KERN_TIMEBASE_SET(tb) pk_timebase_set(tb) #define KERN_INTERRUPT_PREEMPTION_ENABLE() pk_interrupt_preemption_enable() #define KERN_INTERRUPT_PREEMPTION_DISABLE() pk_interrupt_preemption_disable() #define KERN_TIMER_CREATE(timer, callback, arg) \ pk_timer_create(timer, callback, arg) #define KERN_TIMER_CREATE_NONPREEMPTIBLE(timer, callback, arg) \ pk_timer_create_nonpreemptible(timer, callback, arg) #define KERN_TIMER_SCHEDULE_ABSOLUTE(timer, time, period) \ pk_timer_schedule_absolute(timer, time, period) #define KERN_TIMER_SCHEDULE(timer, interval, period) \ pk_timer_schedule(timer, interval, period) #define KERN_TIMER_CANCEL(timer) \ pk_timer_cancel(timer) #define KERN_TIMER_INFO_GET(timer, timeout, active) \ pk_timer_info_get(timer, timeout, active) #define KERN_THREAD_CREATE(thread, thread_routine, arg, stack, stack_size, priority) \ pk_thread_create(thread, thread_routine, arg, stack, stack_size, priority) #define KERN_THREAD_INFO_GET(thread, state, priority, runnable) \ pk_thread_info_get(thread, state, priority, runnable) #define KERN_THREAD_PRIORTY_CHANGE(thread, new_priority, old_priority) \ pk_thread_priority_change(thread, new_priority, old_priority) #define KERN_THREAD_AT_PRIORITY(priority, thread) \ pk_thread_at_priority(priority, thread) #define KERN_THREAD_PRIORITY_SWAP(thread_a, thread_b) \ pk_thread_priority_swap(thread_a, thread_b) #define KERN_START_THREADS() pk_start_threads() #define KERN_THREAD_RESUME(thread) pk_thread_resume(thread) #define KERN_THREAD_SUSPEND(thread) pk_thread_suspend(thread) #define KERN_THREAD_DELETE(thread) pk_thread_delete(thread) #define KERN_COMPLETE() pk_complete() #define KERN_SLEEP_ABSOLUTE(time) pk_sleep_absolute(time) #define KERN_SLEEP(interval) pk_sleep(interval) #define KERN_SEMAPHORE_CREATE(semaphore, initial_count, max_count) \ pk_semaphore_create(semaphore, initial_count,max_count) #define KERN_SEMAPHORE_STATIC_CREATE(sem, initial_count, max_count) \ PK_SEMAPHORE(sem, initial_count, max_count) #define KERN_SEMAPHORE_INITIALIZATION(_initial_count, _max_count) \ PK_SEMAPHORE_INITIALIZATION(_initial_count, _max_count) #define KERN_SEMAPHORE_INFO_GET(semaphore, count, pending) \ pk_semaphore_info_get(semaphore, count, pending) #define KERN_SEMAPHORE_POST(semaphore) \ pk_semaphore_post(semaphore) #define KERN_SEMAPHORE_PEND(semaphore, timeout) \ pk_semaphore_pend(semaphore, timeout) #define KERN_SEMAPHORE_RELEASE_ALL(semaphore) \ pk_semaphore_release_all(semaphore) #define KERN_SEMAPHORE_POST_HANDLER(arg, irq, priority) \ pk_semaphore_post_handler(arg, irq, priority) #define KERN_HALT() \ pk_halt() #define KERN_PANIC(code) \ PK_PANIC(code) #define KERN_DEQUE_SENTINEL_CREATE(deque) \ pk_deque_sentinel_create(deque) #define KERN_DEQUE_SENTINEL_STATIC_CREATE(deque) \ PK_DEQUE_SENTINEL_STATIC_CREATE(deque) #define KERN_DEQUE_SENTINEL_INIT(dq_addr) \ PK_DEQUE_SENTINEL_INIT(dq_addr) #define KERN_DEQUE_ELEMENT_CREATE(element) \ pk_deque_element_create(element) #define KERN_DEQUE_ELEMENT_STATIC_CREATE(deque) \ PK_DEQUE_ELEMENT_STATIC_CREATE(deque) #define KERN_DEQUE_ELEMENT_INIT() \ PK_DEQUE_ELEMENT_INIT() #define KERN_DEQUE_IS_EMPTY(deque) \ pk_deque_is_empty(deque) #define KERN_DEQUE_IS_QUEUED(element) \ pk_deque_is_queued(element) #define KERN_DEQUE_PUSH_BACK(deque, element) \ pk_deque_push_back(deque, element) #define KERN_DEQUE_PUSH_FRONT(deque, element) \ pk_deque_push_front(deque, element) #define KERN_DEQUE_POP_FRONT(deque) \ pk_deque_pop_front(deque) #define KERN_DEQUE_DELETE(element) \ pk_deque_delete(element) #define KERN_IRQ_HANDLER(f) \ PK_IRQ_HANDLER(f) #define KERN_IRQ_SETUP(irq, polarity, trigger) \ pk_irq_setup(irq, polarity, trigger) #define KERN_IRQ_HANDLER_SET(irq, handler, arg, priority) \ pk_irq_handler_set(irq, handler, arg) #define KERN_IRQ_ENABLE(irq) \ pk_irq_enable(irq) #define KERN_IRQ_DISABLE(irq) \ pk_irq_disable(irq) #define KERN_IRQ_STATUS_CLEAR(irq) \ pk_irq_status_clear(irq) #define KERN_IRQ_STATUS_SET(irq, value) \ pk_irq_status_set(irq, value) #define KERN_IRQ_FAST2FULL(fast_handler, full_handler) \ PK_IRQ_FAST2FULL(fast_handler, full_handler) #define KERN_CRITICAL_SECTION_ENTER(priority, pctx) \ pk_critical_section_enter(pctx) #define KERN_CRITICAL_SECTION_EXIT(pctx) \ pk_critical_section_exit(pctx) #define KERN_CONTEXT_CRITICAL_INTERRUPT() \ (0) #define KERN_ERROR_IF(condition, code) PK_ERROR_IF(condition, code) #define KERN_CAST_POINTER(t, p) PK_CAST_POINTER(t, p) #define KERN_STATIC_ASSERT(cond) PK_STATIC_ASSERT(cond) #else /// ----------------------- Kernel type not defined -------------------------- #error "Kernel type must be defined in img_defs.mk" #endif /*__SSX__*/ #endif /*__ASSEMBLER__*/ #endif /* __KERNEL_H__ */