microkernel: remove deprecated task IRQs

Change-Id: I06393c8ee0e864105cd0183c92e453638679fe81
Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2016-08-01 15:12:28 -07:00 committed by Inaky Perez-Gonzalez
commit d73a9bb9c6
9 changed files with 0 additions and 358 deletions

16
Kbuild
View file

@ -1,11 +1,5 @@
# vim: filetype=make # vim: filetype=make
ifneq ($(strip $(CONFIG_MAX_NUM_TASK_IRQS)),)
ifneq (${CONFIG_MAX_NUM_TASK_IRQS},0)
TASK_IRQS=y
endif
endif
ifneq ("$(wildcard $(MDEF_FILE))","") ifneq ("$(wildcard $(MDEF_FILE))","")
MDEF_FILE_PATH=$(strip $(MDEF_FILE)) MDEF_FILE_PATH=$(strip $(MDEF_FILE))
else else
@ -28,16 +22,6 @@ define filechk_prj.mdef
echo " TASKGROUP FPU";\ echo " TASKGROUP FPU";\
echo " TASKGROUP SSE";\ echo " TASKGROUP SSE";\
echo; \ echo; \
if test "$(TASK_IRQS)" = "y"; then \
echo "% Task IRQ objects";\
echo "% EVENT NAME HANDLER"; \
echo "% ======================================="; \
i=0; \
while [ $$i -lt $(CONFIG_MAX_NUM_TASK_IRQS) ]; do \
echo " EVENT _TaskIrqEvt$$i NULL"; \
i=$$(($$i+1));\
done; \
fi; \
if test -e "$(MDEF_FILE_PATH)"; then \ if test -e "$(MDEF_FILE_PATH)"; then \
cat $(MDEF_FILE_PATH); \ cat $(MDEF_FILE_PATH); \
fi;) fi;)

View file

@ -29,13 +29,6 @@ Pipes
:project: Zephyr :project: Zephyr
:content-only: :content-only:
Interrupt Services
******************
.. doxygengroup:: microkernel_irq
:project: Zephyr
:content-only:
Mailboxes Mailboxes
********* *********

View file

@ -46,11 +46,7 @@ extern "C" {
*/ */
#define MK_ISR_NAME(x) __isr__##x #define MK_ISR_NAME(x) __isr__##x
#ifdef CONFIG_MICROKERNEL
#define ALL_DYN_IRQ_STUBS (CONFIG_NUM_DYNAMIC_STUBS + CONFIG_MAX_NUM_TASK_IRQS)
#elif defined(CONFIG_NANOKERNEL)
#define ALL_DYN_IRQ_STUBS (CONFIG_NUM_DYNAMIC_STUBS) #define ALL_DYN_IRQ_STUBS (CONFIG_NUM_DYNAMIC_STUBS)
#endif
#define ALL_DYN_EXC_STUBS (CONFIG_NUM_DYNAMIC_EXC_STUBS + \ #define ALL_DYN_EXC_STUBS (CONFIG_NUM_DYNAMIC_EXC_STUBS + \
CONFIG_NUM_DYNAMIC_EXC_NOERR_STUBS) CONFIG_NUM_DYNAMIC_EXC_NOERR_STUBS)

View file

@ -55,7 +55,6 @@ extern "C" {
#include <microkernel/event.h> #include <microkernel/event.h>
#include <microkernel/memory_pool.h> #include <microkernel/memory_pool.h>
#include <microkernel/pipe.h> #include <microkernel/pipe.h>
#include <microkernel/task_irq.h>
/** /**
* @} * @}

View file

@ -1,102 +0,0 @@
/* taskDevInt.h - APIs for managing task IRQ objects */
/*
* Copyright (c) 2013-2014 Wind River Systems, Inc.
*
* 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.
*/
#ifndef TASK_IRQ_H
#define TASK_IRQ_H
/**
* @brief Microkernel Interrupt Services
* @defgroup microkernel_irq Microkernel Interrupt Services
* @ingroup microkernel_services
* @{
*/
#include <microkernel/base_api.h>
#include <toolchain/gcc.h>
#ifdef __cplusplus
extern "C" {
#endif
#define INVALID_VECTOR 0xFFFFFFFF
/**
* @fn uint32_t task_irq_alloc(kirq_t irq_obj, uint32_t irq,
* uint32_t priority, uint32_t flags)
* @brief Register a task IRQ object.
*
* This routine connects a task IRQ object to a system interrupt based
* upon the specified IRQ and priority values.
*
* IRQ allocation is done via the microkernel server fiber, making simultaneous
* allocation requests single-threaded.
*
* @param irq_obj IRQ object identifier.
* @param irq Request IRQ.
* @param priority Requested interrupt priority.
* @param flags IRQ flags.
*
* @return assigned interrupt vector if successful, INVALID_VECTOR if not
*/
uint32_t __deprecated task_irq_alloc(kirq_t irq_obj, uint32_t irq,
uint32_t priority, uint32_t flags);
/**
*
* @fn void task_irq_ack(kirq_t irq_obj)
* @brief Re-enable a task IRQ object's interrupt.
*
* This re-enables the interrupt for a task IRQ object.
*
* @param irq_obj IRQ object identifier.
*
* @return N/A
*/
void __deprecated task_irq_ack(kirq_t irq_obj);
/**
* @fn int task_irq_wait(kirq_t irq_obj, int32_t timeout)
* @brief Wait for task IRQ to signal an interrupt.
*
* This routine waits up to @a timeout ticks for the IRQ object @a irq_obj
* to signal an interrupt.
*
* @param irq_obj IRQ object identifier.
* @param timeout Determines the action when task IRQ is not yet signaled.
* For TICKS_NONE, return immediately.
* For TICKS_UNLIMITED, wait as long as necessary.
* Otherwise, wait up to the specified number of ticks before timing out.
*
* @retval RC_OK Successfully detected signaled interrupt.
* @retval RC_TIME Timed out while waiting for interrupt.
* @retval RC_FAIL Failed to immediately detect signaled interrupt when
* @a timeout = TICKS_NONE.
* @sa TICKS_NONE, TICKS_UNLIMITED
*/
int __deprecated task_irq_wait(kirq_t irq_obj, int32_t timeout);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* TASK_IRQ_H */

View file

@ -101,16 +101,6 @@ config WORKLOAD_MONITOR
This option instructs the kernel to record the percentage of time This option instructs the kernel to record the percentage of time
the system is doing useful work (i.e. is not idle). the system is doing useful work (i.e. is not idle).
config MAX_NUM_TASK_IRQS
int
prompt "Number of task IRQ objects"
default 0
depends on MICROKERNEL
help
This option specifies the maximum number of IRQs that may be
utilized by task level device drivers. A value of zero disables
this feature.
menu "Timer API Options" menu "Timer API Options"
config TIMESLICING config TIMESLICING

View file

@ -9,7 +9,6 @@ obj-y += k_move_data.o
obj-y += k_ticker.o obj-y += k_ticker.o
obj-y += k_memory_map.o obj-y += k_memory_map.o
obj-y += k_memory_pool.o obj-y += k_memory_pool.o
obj-y += k_irq.o
obj-y += k_nop.o obj-y += k_nop.o
obj-y += k_offload.o obj-y += k_offload.o
obj-y += k_event.o obj-y += k_event.o

View file

@ -1,199 +0,0 @@
/*
* Copyright (c) 2013-2014 Wind River Systems, Inc.
*
* 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.
*/
/**
* @brief Task IRQ kernel services
*
* This module manages the interrupt functionality between a task level device
* driver and the kernel.
*
* A task level device driver allocates a specific task IRQ object by providing
* an IRQ and priority level; the registration process allocates an interrupt
* vector, sets up an ISR, and enables the associated interrupt. When an
* interrupt occurs, the ISR handler signals an event specific to the IRQ object.
* The task level device driver tests/waits on this event number to determine
* if/when the interrupt has occurred. As the ISR also disables the interrupt, the
* task level device driver subsequently make a request to have the interrupt
* enabled again.
*
* These routines perform error checking to ensure that an IRQ object can only be
* allocated by a single task, and that subsequent operations on that IRQ object
* are only performed by that task. This checking is necessary to ensure that
* a task cannot impact the operation of an IRQ object it does not own.
*
*/
#if (CONFIG_MAX_NUM_TASK_IRQS > 0)
#include <nano_private.h>
#include <microkernel.h>
#include <micro_private.h>
#include <misc/__assert.h>
#define MAX_TASK_IRQS CONFIG_MAX_NUM_TASK_IRQS
#define INVALID_TASK -1
/* task IRQ object registration request */
struct irq_obj_reg_arg {
kirq_t irq_obj; /* IRQ object identifier */
uint32_t irq; /* IRQ of device */
ktask_t task_id; /* requesting task */
};
/* task IRQ object type */
struct task_irq_info {
ktask_t task_id; /* task ID of task IRQ object's owner */
uint32_t irq; /* IRQ used by task IRQ object */
kevent_t event; /* event number assigned to task IRQ object */
uint32_t vector; /* interrupt vector assigned to task IRQ object */
};
/* task IRQ object array */
static struct task_irq_info task_irq_object[MAX_TASK_IRQS] = {
[0 ...(MAX_TASK_IRQS - 1)].task_id = INVALID_TASK
};
/* array of event id used by task IRQ objects */
extern const kevent_t _TaskIrqEvt_objIds[];
/**
*
* @brief ISR for task IRQ objects
*
* This ISR handles interrupts generated by registered task IRQ objects.
*
* The ISR triggers an event signal specified by the event number associated
* with a particular task IRQ object; the interrupt for the task IRQ object
* is then disabled. The parameter provided to the ISR is a structure that
* contains information about the objects's vector, IRQ, and event number.
*
* This ISR does not facilitate an int acknowledgment as it presumes that an
* End of Interrupt (EOI) routine is provided by the interrupt controller that
* is being used.
*
* @param parameter Pointer to task IRQ object
*
* @return N/A
*/
static void task_irq_int_handler(void *parameter)
{
struct task_irq_info *irq_obj_ptr = parameter;
isr_event_send(irq_obj_ptr->event);
irq_disable(irq_obj_ptr->irq);
}
/**
*
* @brief Re-enable a task IRQ object's interrupt
*
* This re-enables the interrupt for a task IRQ object.
* @param irq_obj IRQ object identifier
*
* @return N/A
*/
void task_irq_ack(kirq_t irq_obj)
{
__ASSERT(irq_obj < MAX_TASK_IRQS, "Invalid IRQ object");
__ASSERT(task_irq_object[irq_obj].task_id == task_id_get(),
"Incorrect Task ID");
irq_enable(task_irq_object[irq_obj].irq);
}
int task_irq_wait(kirq_t irq_obj, int32_t timeout)
{
__ASSERT(irq_obj < MAX_TASK_IRQS, "Invalid IRQ object");
__ASSERT(task_irq_object[irq_obj].task_id == task_id_get(),
"Incorrect Task ID");
return task_event_recv(task_irq_object[irq_obj].event, timeout);
}
/**
*
* @brief Allocate a task IRQ object
*
* This routine allocates a task IRQ object to a task.
* @param arg Pointer to registration request arguments
*
* @return ptr to allocated task IRQ object if successful, NULL if not
*/
static int _k_task_irq_alloc(void *arg)
{
struct irq_obj_reg_arg *argp = (struct irq_obj_reg_arg *)arg;
struct task_irq_info *irq_obj_ptr; /* ptr to task IRQ object */
int curr_irq_obj; /* IRQ object loop counter */
/* Fail if the requested IRQ object is already in use */
if (task_irq_object[argp->irq_obj].task_id != INVALID_TASK) {
return (int)NULL;
}
/* Fail if the requested IRQ is already in use */
for (curr_irq_obj = 0; curr_irq_obj < MAX_TASK_IRQS; curr_irq_obj++) {
if ((task_irq_object[curr_irq_obj].irq == argp->irq) &&
(task_irq_object[curr_irq_obj].task_id != INVALID_TASK)) {
return (int)NULL;
}
}
/* Take ownership of specified IRQ object */
irq_obj_ptr = &task_irq_object[argp->irq_obj];
irq_obj_ptr->task_id = argp->task_id;
irq_obj_ptr->irq = argp->irq;
irq_obj_ptr->event = _TaskIrqEvt_objIds[argp->irq_obj];
irq_obj_ptr->vector = INVALID_VECTOR;
return (int)irq_obj_ptr;
}
uint32_t task_irq_alloc(kirq_t irq_obj, uint32_t irq, uint32_t priority,
uint32_t flags)
{
struct irq_obj_reg_arg arg; /* IRQ object registration request arguments */
struct task_irq_info *irq_obj_ptr; /* ptr to task IRQ object */
/* Allocate the desired IRQ object and IRQ */
arg.irq_obj = irq_obj;
arg.irq = irq;
arg.task_id = task_id_get();
irq_obj_ptr = (struct task_irq_info *)task_offload_to_fiber(_k_task_irq_alloc,
(void *)&arg);
if (irq_obj_ptr == NULL) {
return INVALID_VECTOR;
}
irq_obj_ptr->vector = irq_connect_dynamic(
irq, priority, task_irq_int_handler, (void *)irq_obj_ptr,
flags);
irq_enable(irq);
return irq_obj_ptr->vector;
}
#endif /* (CONFIG_MAX_NUM_TASK_IRQS > 0) */

View file

@ -39,7 +39,6 @@ heap_pos_in_pool_list = -1
num_kargs = 0 num_kargs = 0
num_timers = 0 num_timers = 0
num_prios = 0 num_prios = 0
num_task_irqs = 0
task_list = [] task_list = []
event_list = [] event_list = []
@ -439,8 +438,6 @@ def kernel_main_c_priorities():
def kernel_main_c_events(): def kernel_main_c_events():
""" Generate event variables """ """ Generate event variables """
global num_task_irqs
# event descriptors # event descriptors
# pre-defined event for timer # pre-defined event for timer
@ -462,20 +459,6 @@ def kernel_main_c_events():
kernel_main_c_out("DEFINE_EVENT(%s, %s);\n" % (event[0], event[1])) kernel_main_c_out("DEFINE_EVENT(%s, %s);\n" % (event[0], event[1]))
if (event[0].startswith("_TaskIrqEvt")):
num_task_irqs += 1
if (num_task_irqs > 0):
kernel_main_c_out("const kevent_t _TaskIrqEvt_objIds[] = {\n")
for i in range(0, num_task_irqs):
kernel_main_c_out(
" (kevent_t)&_k_event_obj__TaskIrqEvt%d,\n" % (i)
)
kernel_main_c_out("};\n")
def kernel_main_c_mutexes(): def kernel_main_c_mutexes():
""" Generate mutex variables """ """ Generate mutex variables """
@ -905,7 +888,6 @@ def generate_obj_id_lines(obj_types):
def generate_sysgen_h_obj_ids(): def generate_sysgen_h_obj_ids():
global sysgen_h_data global sysgen_h_data
global num_task_irqs
# mutex object ids # mutex object ids