/*
 * Copyright 2019, Data61, CSIRO (ABN 41 687 119 230)
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/**
 * The IRQ server helps to manage the IRQs in a system. There are 2 API levels
 * in the design:
 *   1. [irq server thread] An IRQ server node is a standalone thread which waits
 *                          for the arrival of any IRQ that is being managed by a
 *                          particular irq server node. When an IRQ is received,
 *                          the irq server thread will either forward the irq
 *                          information to a registered synchronous endpoint, or
 *                          call the appropriate handler function directly.
 *   2. [irq server]        A dynamic collection of server threads. When
 *                          registering an IRQ call back function, the irq server
 *                          will attempt to deligate the IRQ to an irq server node
 *                          that has not yet reached capacity. If no node can accept
 *                          the IRQ, it will alert the user that a new irq server
 *                          thread needs to be created to support the additional demand.
 *
 * ++ Special notes ++
 *
 * Performance
 *   The application can achieve greater performance by configuring the irq
 *   server, or irq server threads, to call the IRQ handler functions directly.
 *   This is done by not providing an endpoint in the creation of an irq server
 *   interface. The application must take care to ensure that all concurrency
 *   issues are addressed.
 *
 * Resource availability
 *   The irq server API family accept resource allocators as arguments to some
 *   function calls. These resource allocators
 *   must be kept available indefinitely.
 */

#pragma once

#include <autoconf.h>
#include <sel4utils/gen_config.h>

#include <sel4/sel4.h>
#include <vspace/vspace.h>
#include <vka/vka.h>
#include <simple/simple.h>
#include <platsupport/io.h>
#include <platsupport/irq.h>
#include <sel4platsupport/irq.h>

typedef struct irq_server irq_server_t;

typedef int thread_id_t;

/**
 * Initialises an IRQ server. The server will manage threads that are
 * explicitly created by the user to handle incoming IRQs. The server
 * delegates most of the IRQ cap creation and pairing to the IRQ interface in
 * libsel4platsupport.
 * @param[in] vspace            The current vspace
 * @param[in] vka               Allocator for creating kernel objects
 * @param[in] priority          The priority of spawned threads
 * @param[in] simple            A simple interface for creating IRQ caps
 * @param[in] cspace            The cspace of the current thread
 * @param[in] delivery_ep       The endpoint to send alerts about IRQ's to
 * @param[in] label             A label to use when sending to an IPC to an endpoint
 * @param[in] nirqs             The maximum number of irqs to support
 * @return                      A valid pointer to an irq_server_t instance, otherwise NULL
 */
irq_server_t *irq_server_new(vspace_t *vspace, vka_t *vka, seL4_Word priority,
                             simple_t *simple, seL4_CPtr cspace, seL4_CPtr delivery_ep,
                             seL4_Word label, size_t num_irqs, ps_malloc_ops_t *malloc_ops);

/**
 * Creates a new thread to wait on IRQs.
 * Upon receiving a signal that an IRQ has arrived, the thread will send an IPC message
 * through to the endpoint that was registered with the IRQ server, if any. Otherwise,
 * it will call 'irq_server_handle_irq_ipc' to handle the interrupt.
 *
 * The user can provide a notification for the thread to use, and can mark which bits
 * of the badge that the thread can use for IRQs. If a null cap was provided,
 * the IRQ server can create a notification cap on behalf of the user, the 'usable_mask'
 * parameter will be ignored in this case.
 *
 * A ID will be assigned to this thread and
 * returned to the user, but the user can provide a 'hint' to IRQ server. The server will
 * attempt to assign an ID with the same value as the hint.
 * @param[in] irq_server        A handle to the IRQ server
 * @param[in] provided_ntfn     Notification cap to be provided to thread, can be
 *                              'seL4_CapNull'
 * @param[in] usable_mask       Mask of bits indicating which bits of the badge space
 *                              the thread can use, will be ignore if 'provided_ntfn' is
 *                              'null'
 * @param[in] id_hint           'Hint' to be passed to the IRQ server when assigning an
 *                              ID, >= 0 for a valid hint, -1 otherwise
 */
thread_id_t irq_server_thread_new(irq_server_t *irq_server, seL4_CPtr provided_ntfn,
                                  seL4_Word usable_mask, thread_id_t id_hint);

/**
 * Enable an IRQ and register a callback function. This functionality is
 * delegated to the IRQ interface in libplatsupport.
 * @param[in] irq_server        The IRQ server which shall be responsible for the IRQ
 * @param[in] irq               Information about the IRQ that will be registered
 * @param[in] callback          A callback function to call when the requested IRQ arrives
 * @param[in] callback_data     Client data which should be passed to the registered call
 *                              back function
 * @return                      On success, returns an ID for the IRQ that was assigned by
 *                              the IRQ interface in libsel4platsuport. Otherwise, returns
 *                              an error code
 */
irq_id_t irq_server_register_irq(irq_server_t *irq_server, ps_irq_t irq,
                                 irq_callback_fn_t callback, void *callback_data);

/**
 * Redirects control to the IRQ subsystem to process an arriving IRQ.  The
 * server will read the appropriate message registers to retrieve the
 * information that it needs. This should be called only when an IPC message
 * with the designated label was received on an endpoint that was given to an
 * IRQ server instance.
 * @param[in] irq_server   The IRQ server which is responsible for the received IRQ
 * @param[in] msginfo      An IPC message info header of an IPC message received on
 *                         an endpoint registered with an IRQ server
 */
void irq_server_handle_irq_ipc(irq_server_t *irq_server, seL4_MessageInfo_t msginfo);

/**
 * Waits on the IRQ delivery endpoint for the next IRQ. If an IPC is received, but the
 * label does not match that which was assigned to the IRQ server, the message info and
 * badge are returned to the caller, much like seL4_Recv(...). If the label does match,
 * irq_server_handle_irq_ipc(...) will be called before returning.
 *
 * If an endpoint was not registered with the IRQ server that is passed in, this function
 * is essentially a no-op.
 * @param[in]  irq_server  A handle to the IRQ server
 * @param[out] ret_badge   If badge_ret is not NULL, the received badge will be
 *                         written to badge_ret.
 * @return                 The seL4_MessageInfo_t structure as provided by the
 *                         seL4 kernel in response to a seL4_Recv call. The
 *                         caller may check that the label matches that which
 *                         was registered for the IRQ server in order to
 *                         determine if the received event was destined for the
 *                         IRQ server or if the thread was activated by some
 *                         other IPC event.
 *                         On the error case where the IRQ server passed
 *                         in does not have an endpoint passed in, an empty
 *                         seL4_MessageInfo_t struct will be returned.
 */
seL4_MessageInfo_t irq_server_wait_for_irq(irq_server_t *irq_server, seL4_Word *ret_badge);