source: ReferenceDesigns/w3_802.11/c/wlan_w3_high/w3_high.c

#include "wlan_mac_high_sw_config.h"

#include "xil_cache.h"
#include "wlan_platform_high.h"
#include "w3_high.h"
#include "w3_eth.h"
#include "w3_uart.h"
#include "w3_high_userio.h"
#include "w3_userio_util.h"
#include "w3_iic_eeprom.h"
#include "w3_sw_intr.h"
#include "w3_common.h"
#include "wlan_platform_timer.h"
#include "wlan_common_types.h"
#include "wlan_platform_common.h"

#include "wlan_mac_high.h"
#include "wlan_mac_schedule.h"
#include "wlan_exp_common.h"
#include "wlan_exp_node.h"
#include "wlan_exp_transport.h"
#include "wlan_mac_queue.h"

static const platform_high_dev_info_t w3_platform_high_dev_info = {
        .aux_bram_baseaddr = AUX_BRAM_BASEADDR,
        .aux_bram_size = AUX_BRAM_SIZE - PORTAL_ETH_BD_MEM_SIZE,
        .dram_baseaddr = WLAN_EXP_ETH_BD_MEM_HIGHADDR + 1,
        .dram_size = DRAM_SIZE - WLAN_EXP_ETH_BD_MEM_SIZE,
        .cdma_dev_id = PLATFORM_DEV_ID_CDMA,
        .mailbox_int_id = PLATFORM_INT_ID_MAILBOX,
        .timer_dur_us = TIMER_DUR_US,
};

typedef struct _w3_node_info_t{
    u64                      fpga_dna;                          // FPGA DNA value, unique ID per chip
    s8                       wlan_max_tx_power_dbm;             // RF interface maximum transmit power
    s8                       wlan_min_tx_power_dbm;             // RF interface minimum transmit power
} __attribute__((__packed__)) _w3_node_info_t;
static _w3_node_info_t w3_node_info;
ASSERT_TYPE_SIZE(_w3_node_info_t, 10);

int _init_wlan_exp_node_info();

void wlan_platform_cpu_high_init() {

    Xil_AssertSetCallback((Xil_AssertCallback)wlan_assert_print);

    // Disable I and D cache
    Xil_DCacheDisable();
    Xil_ICacheDisable();

    // Enable exceptions - exceptions *must* be enabled on MicroBlaze
    //  to handle unaligned memory accesses
    microblaze_enable_exceptions();

    // Initialize HW platform
    wlan_platform_common_init();

    // Fill in node info struct
    _init_wlan_exp_node_info();

    return;

}

platform_high_dev_info_t wlan_platform_high_get_dev_info(){
    return w3_platform_high_dev_info;
}

void wlan_platform_high_poll(){
}

int wlan_platform_high_init() {
    int status;

    status = wlan_platform_intc_init(PLATFORM_DEV_ID_INTC);

    status |= wlan_timer_init(PLATFORM_DEV_ID_TIMER, TIMER_DUR_US*(TIMER_FREQ_HZ/1000000)); // 64 usec

    status |= wlan_timer_setup_interrupt(PLATFORM_INT_ID_TIMER, wlan_mac_schedule_poll);


    status |= w3_uart_init();
    status |= w3_uart_setup_interrupt();

    status |= w3_high_userio_init();
    status |= w3_high_userio_setup_interrupt();

    status |= w3_sw_intr_init();

    // Initialize Ethernet in wlan_platform
    status |= w3_wlan_platform_ethernet_init();

    // Set stack protection addresses
    // Set stack protection addresses
    // Linker sets these variables at build time
    extern int _stack_end; ///< Start of the stack (stack counts backwards)
    extern int __stack; ///< End of the stack
    mtshr(&__stack);
    mtslr(&_stack_end);

    return status;
}

void wlan_platform_free_queue_entry_notify(){
#if WLAN_SW_CONFIG_ENABLE_ETH_BRIDGE
    w3_wlan_platform_ethernet_free_queue_entry_notify();
#endif
}


void wlan_platform_high_userio_disp_status(userio_disp_high_status_t status, int status_param){

   static application_role_t application_role = APPLICATION_ROLE_UNKNOWN;

   switch(status){

       case USERIO_DISP_STATUS_IDENTIFY: {
           blink_hex_display(25, 200000);
       } break;

       case USERIO_DISP_STATUS_APPLICATION_ROLE: {
           application_role = (application_role_t)status_param;

           if(application_role == APPLICATION_ROLE_AP){
                // Set Periodic blinking of hex display (period of 500 with min of 2 and max of 400)
                set_hex_pwm_period(500);
                set_hex_pwm_min_max(2, 400);
                enable_hex_pwm();
           }
       } break;

       case USERIO_DISP_STATUS_MEMBER_LIST_UPDATE: {
            if(application_role == APPLICATION_ROLE_AP){
                write_hex_display_with_pwm((u8)status_param);
            } else {
                write_hex_display((u8)status_param);
            }

       } break;

       case USERIO_DISP_STATUS_WLAN_EXP_CONFIGURE: {

           if( status_param ){
               set_hex_display_right_dp(1);
           } else {
               set_hex_display_right_dp(0);
           }
       } break;

       case USERIO_DISP_STATUS_CPU_ERROR: {

           u32 error_code = (u32)status_param;
           if (status_param != WLAN_ERROR_CPU_STOP) {
               // Print error message
               xil_printf("\n\nERROR:  CPU is halting with error code: E%X\n\n", (error_code & 0xF));

               // Set the error code on the hex display
               set_hex_display_error_status(error_code & 0xF);

               // Enter infinite loop blinking the hex display
               blink_hex_display(0, 250000);
            } else {
                // Stop execution
                while (1) {};
            }

       } break;

       default:
       break;
   }


   return;

}

#if WLAN_SW_CONFIG_ENABLE_WLAN_EXP
int wlan_platform_wlan_exp_process_node_cmd(cmd_resp_hdr_t* cmd_hdr, eth_tx_queue_buffer_t* eth_tx_queue_buffer, u8* cmd_processed){

    //
    // IMPORTANT ENDIAN NOTES:
    //     - command
    //         - header - Already endian swapped by the framework (safe to access directly)
    //         - args   - Must be endian swapped as necessary by code (framework does not know the contents of the command)
    //     - response
    //         - header - Will be endian swapped by the framework (safe to write directly)
    //         - args   - Must be endian swapped as necessary by code (framework does not know the contents of the response)
    //

    u32 resp_sent = NO_RESP_SENT;
    u32 cmd_id = CMD_TO_CMDID(cmd_hdr->cmd);

    // Segment 0 length includes a fully formed command response header
    //  because one was created with default values suitable for a responseless
    //  acknowledgment.
    cmd_resp_hdr_t* resp_hdr = (cmd_resp_hdr_t*)(eth_tx_queue_buffer->seg0
                                                 + eth_tx_queue_buffer->seg0_len
                                                 - sizeof(cmd_resp_hdr_t));

    u32* cmd_args_32 = (u32*)((u8*)cmd_hdr + sizeof(cmd_resp_hdr_t));
    u32* resp_args_32 = (u32*)((u8*)resp_hdr + sizeof(cmd_resp_hdr_t));
    u32 resp_index = 0;

    // NOTE: Response header cmd, length, and num_args fields have already been initialized.
    //

    *cmd_processed = 1;

    switch(cmd_id){
        default:
            *cmd_processed = 0;
        break;
        //---------------------------------------------------------------------
        case CMDID_DEV_EEPROM: {


            // Read / Write values from / to EEPROM
            //
            // Write Message format:
            //     cmd_args_32[0]      Command == CMD_PARAM_WRITE_VAL
            //     cmd_args_32[1]      EEPROM (0 = ON_BOARD / 1 = FMC)
            //     cmd_args_32[2]      Address
            //     cmd_args_32[3]      Length (Number of u8 bytes to write)
            //     cmd_args_32[4:]     Values to write (Length u32 values each containing a single byte to write)
            // Response format:
            //     resp_args_32[0]     Status
            //
            // Read Message format:
            //     cmd_args_32[0]      Command == CMD_PARAM_READ_VAL
            //     cmd_args_32[1]      EEPROM Device (1 = ON_BOARD / 0 = FMC)
            //     cmd_args_32[2]      Address
            //     cmd_args_32[3]      Length (number of u8 bytes to read)
            // Response format:
            //     resp_args_32[0]     Status
            //     resp_args_32[1]     Length (Number of u8 bytes read)
            //     resp_args_32[2:]    EEPROM values (Length u32 values each containing a single byte read)
            //
            #define EEPROM_BASEADDR                        XPAR_W3_IIC_EEPROM_ONBOARD_BASEADDR
            #define FMC_EEPROM_BASEADDR                    XPAR_W3_IIC_EEPROM_FMC_BASEADDR

            u32 eeprom_idx;
            int eeprom_status;
            u8 byte_to_write;
            u32 status = CMD_PARAM_SUCCESS;
            u32 msg_cmd = Xil_Ntohl(cmd_args_32[0]);
            u32 eeprom_device = Xil_Ntohl(cmd_args_32[1]);
            u32 eeprom_addr = (Xil_Ntohl(cmd_args_32[2]) & 0xFFFF);
            u32 eeprom_length = Xil_Ntohl(cmd_args_32[3]);
            u32 use_default_resp = WLAN_EXP_TRUE;
            u32 eeprom_ba = EEPROM_BASEADDR;
            u32 max_resp_len = wlan_exp_transport_get_max_pkt_words();

            // Select EEPROM device
            if (eeprom_device) {
                eeprom_ba = EEPROM_BASEADDR;
            } else {
                #if FMC_EEPROM_BASEADDR
                    eeprom_ba = FMC_EEPROM_BASEADDR;
                #else
                    wlan_exp_printf(WLAN_EXP_PRINT_ERROR, print_type_node, "FMC EEPROM not supported\n");
                    msg_cmd = CMD_PARAM_RSVD;
                #endif
            }

            switch (msg_cmd) {
                case CMD_PARAM_WRITE_VAL:
                    wlan_exp_printf(WLAN_EXP_PRINT_INFO, print_type_node, "Write EEPROM:\n");
                    wlan_exp_printf(WLAN_EXP_PRINT_INFO, print_type_node, "  Addr: 0x%08x\n", eeprom_addr);
                    wlan_exp_printf(WLAN_EXP_PRINT_INFO, print_type_node, "  Len:  %d\n", eeprom_length);

                    // Don't bother if length is clearly bogus
                    if(eeprom_length < max_resp_len) {
                        for (eeprom_idx = 0; eeprom_idx < eeprom_length; eeprom_idx++) {
                            // Endian swap payload and extract the byte to write
                            byte_to_write = (Xil_Ntohl(cmd_args_32[eeprom_idx + 4]) & 0xFF);

                            // Write the byte and break if there was an EEPROM failure
                            eeprom_status = iic_eeprom_write_byte(eeprom_ba, (eeprom_addr + eeprom_idx), byte_to_write, XPAR_CPU_ID);

                            if (eeprom_status == IIC_EEPROM_FAILURE) {
                                wlan_exp_printf(WLAN_EXP_PRINT_ERROR, print_type_node, "CMDID_DEV_EEPROM write failed at byte %d\n", eeprom_idx);
                                status = CMD_PARAM_ERROR;
                                break;
                            }
                        }
                    } else {
                        wlan_exp_printf(WLAN_EXP_PRINT_ERROR, print_type_node, "CMDID_DEV_EEPROM write longer than %d bytes\n", max_resp_len);
                        status = CMD_PARAM_ERROR;
                    }
                break;

                case CMD_PARAM_READ_VAL:
                    // There's a chicken and egg problem in this command trying to use the
                    // wlan_exp_add_u32_resp_arg() utility. The first word, status, might
                    // become CMD_PARAM_ERROR as we are well into reading bytes from the
                    // EEPROM. To use the wlan_exp_add_u32_resp_arg() function, we need to
                    // know the final value of the first word before writing any other words
                    // to the response. We will simply leave the "old" resp_index method of
                    // writing a response.
                    wlan_exp_printf(WLAN_EXP_PRINT_INFO, print_type_node, "Read EEPROM:\n");
                    wlan_exp_printf(WLAN_EXP_PRINT_INFO, print_type_node, "  Addr: 0x%08x\n", eeprom_addr);
                    wlan_exp_printf(WLAN_EXP_PRINT_INFO, print_type_node, "  Len:  %d\n", eeprom_length);

                    if (eeprom_length < max_resp_len) {
                        // Don't set the default response
                        use_default_resp = WLAN_EXP_FALSE;

                        for (eeprom_idx = 0; eeprom_idx < eeprom_length; eeprom_idx++) {
                            // Read the byte and break if there was an EEPROM failure
                            eeprom_status = iic_eeprom_read_byte(eeprom_ba, (eeprom_addr + eeprom_idx), XPAR_CPU_ID);

                            if (eeprom_status == IIC_EEPROM_FAILURE) {
                                wlan_exp_printf(WLAN_EXP_PRINT_ERROR, print_type_node, "CMDID_DEV_EEPROM write failed at byte %d\n", eeprom_idx);
                                status = CMD_PARAM_ERROR;
                                break;
                            }

                            // Add the byte read and Endian swap the payload
                            //     - This modified the output Ethernet packet but does not update the resp_index variable
                            resp_args_32[resp_index + eeprom_idx + 2] = Xil_Htonl(eeprom_status & 0xFF);
                        }

                        // Add length argument to response
                        resp_args_32[resp_index++] = Xil_Htonl(status);
                        resp_args_32[resp_index++] = Xil_Htonl(eeprom_idx);
                        resp_index        += eeprom_idx;                       // Update response index for all EEPROM bytes
                        resp_hdr->length  += (resp_index * sizeof(resp_args_32));
                        eth_tx_queue_buffer->seg0_len += (resp_index * sizeof(u32));
                        resp_hdr->num_u32_args = resp_index;

                    } else {
                        wlan_exp_printf(WLAN_EXP_PRINT_ERROR, print_type_node, "CMDID_DEV_EEPROM read longer than %d bytes\n", max_resp_len);
                        status = CMD_PARAM_ERROR;
                    }
                break;

                case CMD_PARAM_RSVD:
                    status = CMD_PARAM_ERROR;
                break;

                default:
                    wlan_exp_printf(WLAN_EXP_PRINT_ERROR, print_type_node, "Unknown command for 0x%6x: %d\n", cmd_id, msg_cmd);
                    status = CMD_PARAM_ERROR;
                break;
            }

            if (use_default_resp) {
                // Send default response
                wlan_exp_add_u32_resp_arg(eth_tx_queue_buffer, resp_hdr, status);
            }

        }

        break;

    }

    return resp_sent;

}
#endif

int wlan_platform_high_copy_info(u8* dest){
    memcpy(dest, &w3_node_info, sizeof(_w3_node_info_t));
    return sizeof(_w3_node_info_t);
}

int _init_wlan_exp_node_info(){

    wlan_mac_hw_info_t hw_info = wlan_platform_get_hw_info();

    xil_printf("Initializing node Serial Number : %s-%05d\n", hw_info.serial_number_prefix, hw_info.serial_number);

    //FIXME: Did I get the endianness right on this?
    w3_node_info.fpga_dna = (((u64)w3_eeprom_read_fpga_dna(EEPROM_BASEADDR, 1)) << 32) + (u64)w3_eeprom_read_fpga_dna(EEPROM_BASEADDR, 0);
    w3_node_info.wlan_max_tx_power_dbm = TX_POWER_MAX_DBM;
    w3_node_info.wlan_min_tx_power_dbm = TX_POWER_MIN_DBM;
    return WLAN_SUCCESS;
}