unified: initial unified kernel implementation

Summary of what this includes:

    initialization:

    Copy from nano_init.c, with the following changes:

    - the main thread is the continuation of the init thread, but an idle
      thread is created as well

    - _main() initializes threads in groups and starts the EXE group

    - the ready queues are initialized

    - the main thread is marked as non-essential once the system init is
      done

    - a weak main() symbol is provided if the application does not provide a
      main() function

    scheduler:

    Not an exhaustive list, but basically provide primitives for:

    - adding/removing a thread to/from a wait queue
    - adding/removing a thread to/from the ready queue
    - marking thread as ready
    - locking/unlocking the scheduler
      - instead of locking interrupts
    - getting/setting thread priority
      - checking what state (coop/preempt) a thread is currenlty running in
    - rescheduling threads
    - finding what thread is the next to run
    - yielding/sleeping/aborting sleep
    - finding the current thread

    threads:

    - Add operationns on threads, such as creating and starting them.

    standardized handling of kernel object return codes:

    - Kernel objects now cause _Swap() to return the following values:
         0      => operation successful
        -EAGAIN => operation timed out
        -Exxxxx => operation failed for another reason

    - The thread's swap_data field can be used to return any additional
    information required to complete the operation, such as the actual
    result of a successful operation.

    timeouts:

    - same as nano timeouts, renamed to simply 'timeouts'
    - the kernel is still tick-based, but objects take timeout values in
      ms for forward compatibility with a tickless kernel.

    semaphores:

      - Port of the nanokernel semaphores, which have the same basic behaviour
      as the microkernel ones. Semaphore groups are not yet implemented.

      - These semaphores are enhanced in that they accept an initial count and a
      count limit. This allows configuring them as binary semaphores, and also
      provisioning them without having to "give" the semaphore multiple times
      before using them.

    mutexes:

    - Straight port of the microkernel mutexes. An init function is added to
    allow defining them at runtime.

    pipes:

    - straight port

    timers:

    - amalgamation of nano and micro timers, with all functionalities
      intact.

    events:

    - re-implementation, using semaphores and workqueues.

    mailboxes:

    - straight port

    message queues:

    - straight port of  microkernel FIFOs

    memory maps:

    - straight port

    workqueues:

    - Basically, have all APIs follow the k_ naming rule, and use the _timeout
    subsystem from the unified kernel directory, and not the _nano_timeout
    one.

    stacks:

    - Port of the nanokernel stacks. They can now have multiple threads
    pending on them and threads can wait with a timeout.

    LIFOs:

    - Straight port of the nanokernel LIFOs.

    FIFOs:

    - Straight port of the nanokernel FIFOs.

Work by: Dmitriy Korovkin <dmitriy.korovkin@windriver.com>
         Peter Mitsis <peter.mitsis@windriver.com>
         Allan Stephens <allan.stephens@windriver.com>
         Benjamin Walsh <benjamin.walsh@windriver.com>

Change-Id: Id3cadb3694484ab2ca467889cfb029be3cd3a7d6
Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>

kernel/unified/sem.c

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2010-2016 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.
+ */
+
+/**
+ * @file
+ *
+ * @brief Nanokernel semaphore object.
+ *
+ * The semaphores are of the 'counting' type, i.e. each 'give' operation will
+ * increment the internal count by 1, if no fiber is pending on it. The 'init'
+ * call initializes the count to 0. Following multiple 'give' operations, the
+ * same number of 'take' operations can be performed without the calling fiber
+ * having to pend on the semaphore, or the calling task having to poll.
+ */
+
+#include <kernel.h>
+#include <nano_private.h>
+#include <misc/debug/object_tracing_common.h>
+#include <toolchain.h>
+#include <sections.h>
+#include <wait_q.h>
+#include <misc/dlist.h>
+#include <sched.h>
+
+void k_sem_init(struct k_sem *sem, unsigned int initial_count,
+		unsigned int limit)
+{
+	__ASSERT(limit != 0, "limit cannot be zero");
+
+	sem->count = initial_count;
+	sem->limit = limit;
+	sys_dlist_init(&sem->wait_q);
+	SYS_TRACING_OBJ_INIT(nano_sem, sem);
+}
+
+void k_sem_give(struct k_sem *sem)
+{
+	int key = irq_lock();
+	struct tcs *first_pending_thread = _unpend_first_thread(&sem->wait_q);
+
+	if (first_pending_thread) {
+		_timeout_abort(first_pending_thread);
+		_ready_thread(first_pending_thread);
+
+		_set_thread_return_value(first_pending_thread, 0);
+
+		if (!_is_in_isr() && _must_switch_threads()) {
+			_Swap(key);
+			return;
+		}
+	} else {
+		if (likely(sem->count != sem->limit)) {
+			sem->count++;
+		}
+	}
+
+	irq_unlock(key);
+}
+
+int k_sem_take(struct k_sem *sem, int32_t timeout)
+{
+	__ASSERT(!_is_in_isr() || timeout == K_NO_WAIT, "");
+
+	unsigned int key = irq_lock();
+
+	if (likely(sem->count > 0)) {
+		sem->count--;
+		irq_unlock(key);
+		return 0;
+	}
+
+	if (timeout == K_NO_WAIT) {
+		irq_unlock(key);
+		return -EBUSY;
+	}
+
+	_pend_current_thread(&sem->wait_q, timeout);
+
+	return _Swap(key);
+}