source: ReferenceDesigns/w3_802.11/c/high_periphs/intc/axi_intc/wlan_platform_intc.c

/** @file wlan_platform_intc.c
 *
 *  Wrapper for axi_intc interrupt controller driver
 *
 *  @copyright Copyright 2013-2019, Mango Communications. All rights reserved.
 *          Distributed under the Mango Communications Reference Design License
 *                See LICENSE.txt included in the design archive or
 *                at http://mangocomm.com/802.11/license
 *
 *  This file is part of the Mango 802.11 Reference Design (https://mangocomm.com/802.11)
 */

#include "wlan_mac_common.h"
#include "wlan_mac_high.h"
#include "wlan_platform_common.h"
#include "wlan_platform_intc.h"
#include "xil_exception.h"
#include "xintc.h"
#include "string.h"

static XIntc InterruptController;
static volatile interrupt_state_t interrupt_state;


/**
 * @brief Connects a peripheral interrupt input to an interrupt service routine
 *
 * @param u32 intr_id
 *      - Interrupt vector ID, from xparameters.h
 * @param wlan_intr_handler_t* handler
 *      - Function pointer to ISR
 * @param void *callback_ref
 *      - Argument passed to every invocation of the ISR
 *
 * @return int
 *      - Returns a non-zero error if interrupt cannot be connected. Refer to axi_intc driver for error codes.
 */
int wlan_platform_interrupt_connect(u32 intr_id, wlan_intr_handler_t handler, void *callback_ref) {
    int s;

    s = XIntc_Connect(&InterruptController, intr_id, (XInterruptHandler)handler, callback_ref);

    if(s == XST_SUCCESS) s = WLAN_SUCCESS;

    return s;
}

/**
 * @brief Enables a peripheral interrupt input
 *
 * @param u32 intr_id
 *      - Interrupt vector ID, from xparameters.h
*/
void wlan_platform_interrupt_enable(u32 intr_id) {

    XIntc_Enable(&InterruptController, intr_id);

    return;
}

/**
 * @brief Disables a peripheral interrupt input
 *
 * @param u32 intr_id
 *      - Interrupt vector ID, from xparameters.h
*/
void wlan_platform_interrupt_disable(u32 intr_id) {

    XIntc_Disable(&InterruptController, intr_id);

    return;
}

/**
 * @brief Initializes the axi_intc interrupt controller core
 *
 * @param u32 intc_dev_id
 *      - Device ID for axi_intc core, from xparameters.h

 * @return int
 *      - Returns an error (-1) if the interrupt controller init fails. Refer to the
 *      axi_intc driver for specific error codes.
 *
 * @note This init function does not enable any interrupt inputs and leaves the interrupt output
 * disabled. The calling code must later enable the interrupt output by calling
 * wlan_platform_intc_set_state(INTERRUPTS_ENABLED)
 */
int wlan_platform_intc_init(u32 intc_dev_id) {
    int s;

    /* XIntc_Initialize() doesn't deal well with a reboot
     * of CPU_HIGH where interrupt peripherals are still
     * running. We'll explicitly do the following before
     * re-initializing the interrupt controller:
     *
     * - Disable IRQ output signal
     * - Disable all interrupt sources
     * - Acknowledge all sources
     */
    XIntc_Config *CfgPtr = XIntc_LookupConfig(intc_dev_id);

    XIntc_Out32(CfgPtr->BaseAddress + XIN_MER_OFFSET, 0);
    XIntc_Out32(CfgPtr->BaseAddress + XIN_IER_OFFSET, 0);
    XIntc_Out32(CfgPtr->BaseAddress + XIN_IAR_OFFSET, 0xFFFFFFFF);

    bzero(&InterruptController, sizeof(XIntc));

    s = XIntc_Initialize(&InterruptController, intc_dev_id);
    if ((s != XST_SUCCESS)) {
        xil_printf("wlan_platform_intc.c: XIntc_Initialize failed (%d)\n", s);
        return s;
    }

    // The axi_intc driver has two modes for processing multiple asserted interrupts
    //  We need the "Service All Interrupts" mode where the controller handles interrupts
    //   in order of priority, but always serves all asserted interrupts before going back
    //   to a higher-priority, still-asserted interrupt
    XIntc_SetOptions(&InterruptController, XIN_SVC_ALL_ISRS_OPTION);

    // Connect the interrupt controller's exception handler to the CPU Interrupt exception
    Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
                                 (Xil_ExceptionHandler) XIntc_DeviceInterruptHandler,
                                 (void *)((u32)intc_dev_id));


    return WLAN_SUCCESS;
}

/**
 * @brief Sets the stopped/started state of the interrupt controller
 *
 * @param interrupt_state_t new_interrupt_state
 *      - State to return interrupts. Typically, this argument is the output of a previous
 *      call to wlan_platform_intc_stop()
 * @return int
 *      - Returns an error (-1) if the caller requests to enable interrupts
 *      but the controller is either not ready or already started. Typically
 *      the caller can ignore this error, as failing to start an already-started
 *      controller leaves hardware in the desired state.
 */
inline int wlan_platform_intc_set_state(interrupt_state_t new_interrupt_state) {
    interrupt_state = new_interrupt_state;

    if(interrupt_state == INTERRUPTS_ENABLED) {
        if(InterruptController.IsReady && InterruptController.IsStarted == 0) {
            return XIntc_Start(&InterruptController, XIN_REAL_MODE);
        } else {
            return WLAN_FAILURE;
        }
    } else {
        return WLAN_SUCCESS;
    }
}

/**
 * @brief Returns the state of the interrupt controller
 *
 * This function checks the state of the interrupt controller but does not
 * alter the state. Callers can use this function to know whether interrupts
 * are currently enabled or disabled.
 *
 * @param None
 * @returns interrupt_state_t INTERRUPTS_ENABLED or INTERRUPTS_DISABLED
 */
interrupt_state_t wlan_platform_intc_get_state() {
    return interrupt_state;
}

/**
 * @brief Starts the interrupt controller
 *
 * This function starts the interrupt controller, enabling the interrupt output to the CPU.
 *
 * @param None
 * @return 0 on success
 */
inline int wlan_platform_intc_start() {
    interrupt_state = INTERRUPTS_ENABLED;

    return XIntc_Start(&InterruptController, XIN_REAL_MODE);
}

/**
 * @brief Stop the interrupt controller
 *
 * This function stops the interrupt controller, effectively pausing interrupts. The function
 * returns the previous state of interrupts (ENABLED or DISABLED). This return value should
 * be passed to wlan_platform_intc_set_state() to restore the state of interrupts. This stop/
 * restore scheme makes nested calls to stop()/set_state() safe
 *
 * @param None
 * @return interrupt_state_t
 *      - INTERRUPTS_ENABLED if interrupts were enabled at the time this function was called
 *      - INTERRUPTS_DISABLED if interrupts were disabled at the time this function was called
 *
 * @note Interrupts that occur while the interrupt controller is off will be executed once it is
 * turned back on. They will not be "lost" as the interrupt inputs to the controller will remain
 * high.
 */
inline interrupt_state_t wlan_platform_intc_stop() {
    interrupt_state_t curr_state = interrupt_state;
    if(InterruptController.IsReady && InterruptController.IsStarted) XIntc_Stop(&InterruptController);
    interrupt_state = INTERRUPTS_DISABLED;
    return curr_state;
}