Platform Functions

Functions
void	sd_wl18xx_ant_config (uint8_t ant)
	WL18xx Antenna Configuration Outputs antenna select pins for the wireless module. More...
void	sd_zynq_clk_enable (uint8_t en)
	Zynq Clock Enable Enables the main clock source for the Zynq APU. More...
void	sd_zynq_jtag_enable (uint8_t en)
	Zynq JTAG Enable Enables the JTAG interface for programming the PS or PL. More...
void	sd_wl_clk_enable (uint8_t en)
	Wireless Clock Enable Enable the wireless module 32kHz clock source. More...
void	sd_bt_enable (uint8_t en)
	Bluetooth Enable Enable the Bluetooth interface on the wireless module. More...
void	sd_zynq_boot_config (enum sd_zynq_boot boot)
	Zynq Boot Config Outputs boot select pins to zynq for desired boot media source. More...
enum sd_zynq_boot	sd_boot_select (void)
	Boot selection.
enum sd_uart_usb_err	sd_uart_usb_bridge_init (void)
	UART to USB Bridge Initialization Initialize UART device structure, UART to USB bridge buffer and set the UART device to use the (previously initialized) UART peripheral and newly initialized buffer. More...
enum sd_uart_usb_err	sd_uart_usb_transmit (struct sd_uart_dev *dev)
	UART to USB Bridge Transmission Transmit the buffer that has been recieved on the bridged UART over USB communications device. More...
void	sd_dfu_start (void)
	Enter Device Firmware Upgrade Mode Prepare device to enter system memory by disabling peripheral clocks, disable PLL, clear pending interrupts and disable interrupts. More...
void	sd_zynq_enable (void)
	Enable Zynq Power Enable the Zynq power rails by setting the enable pin high. More...
void	sd_zynq_disable (void)
	Disable Zynq Power Disable the Zynq power rails by setting the enable pin low. More...

Detailed Description

Function Documentation

sd_bt_enable()

void sd_bt_enable

(

uint8_t

enable

)

#include <Inc/sd_platform.h>

Bluetooth Enable Enable the Bluetooth interface on the wireless module.

Parameters

enable

State to set for Bluetooth interface

Return values

None

{
    GPIO_PinState en = enable ? GPIO_PIN_SET : GPIO_PIN_RESET;
    
    HAL_GPIO_WritePin(WL18xx_BT_EN_GPIO_Port, 
              WL18xx_BT_EN_Pin, en);
}

sd_dfu_start()

void sd_dfu_start

(

void

)

#include <Inc/sd_platform.h>

Enter Device Firmware Upgrade Mode Prepare device to enter system memory by disabling peripheral clocks, disable PLL, clear pending interrupts and disable interrupts.

Disable peripheral clocks

Disable PLL

Disable systick

Run to stack pointer and execute code from system memory

{
    void (*boot_jump)(void);
    
    __GPIOA_CLK_DISABLE();
    __GPIOB_CLK_DISABLE();
    __GPIOC_CLK_DISABLE();
    __GPIOD_CLK_DISABLE();
    __GPIOE_CLK_DISABLE();
    __GPIOF_CLK_DISABLE();
    
    RCC->CR    |= (uint32_t)0x00000001; /* Set HSION bit */
    RCC->CFGR  &= (uint32_t)0x08FFB80C; /* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */
    RCC->CR    &= (uint32_t)0xFEF6FFFF; /* Reset HSEON, CSSON and PLLON bits */
    RCC->CR    &= (uint32_t)0xFFFBFFFF; /* Reset HSEBYP bit */
    RCC->CFGR  &= (uint32_t)0xFFC0FFFF; /* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
    RCC->CFGR2 &= (uint32_t)0xFFFFFFF0; /* Reset PREDIV1[3:0] bits */
    RCC->CFGR3 &= (uint32_t)0xFFF0FEAC; /* Reset USARTSW[1:0], I2CSW, CECSW and ADCSW bits */
    RCC->CR2   &= (uint32_t)0xFFFFFFFE; /* Reset HSI14 bit */
    RCC->CIR    = 0x00000000;       /* Disable all interrupts */
    
    SysTick->CTRL = 0;
    SysTick->LOAD = 0;
    SysTick->VAL = 0;
    
    __set_MSP(BOOT_STACK_ADDR);
    boot_jump = (void (*)(void))(*((uint32_t *)(SYS_MEM_START_ADDR + 4)));
    boot_jump();
    while (1);
}

sd_uart_usb_bridge_init()

enum sd_uart_usb_err sd_uart_usb_bridge_init

(

void

)

#include <Inc/sd_platform.h>

UART to USB Bridge Initialization Initialize UART device structure, UART to USB bridge buffer and set the UART device to use the (previously initialized) UART peripheral and newly initialized buffer.

Return values

State

of UART USB bridge after initialization

{
    /* Initialize the UART device(s) */
//  if (sd_uart_dev_init(&uart1_dev) != SD_UART_SUCCESS)
//      return SD_UART_USB_ERROR;
//  
//  if (sd_uart_dev_init(&uart2_dev) != SD_UART_SUCCESS)
//      return SD_UART_USB_ERROR;
//  
//  /* Initialize the UART <--> USB Buffer */
//  if (sd_char_buff_init(&uart1_rx_cbuff, 
//                CONS_UART_RX_BUFF_SIZE, 
//                uart1_rx_buff) != SD_BUFF_SUCCESS)
//      return SD_UART_USB_ERROR;
//  
//  if (sd_char_buff_init(&uart2_rx_cbuff, 
//                CONS_UART_RX_BUFF_SIZE,
//                uart2_rx_buff) != SD_BUFF_SUCCESS)
//      return SD_UART_USB_ERROR;
//  
//  /* Set the UART device with the peripheral and buffer*/
//  if (sd_uart_rx_init(&uart1_dev, &huart1, &uart1_rx_cbuff) != SD_BUFF_SUCCESS)
//      return SD_UART_USB_ERROR;
//  
//  if (sd_uart_rx_init(&uart2_dev, &huart2, &uart2_rx_cbuff) != SD_BUFF_SUCCESS)
//      return SD_UART_USB_ERROR;

    return SD_UART_USB_SUCCESS;
}

sd_uart_usb_transmit()

enum sd_uart_usb_err sd_uart_usb_transmit ( struct sd_uart_dev *  dev )

inline

#include <Inc/sd_platform.h>

UART to USB Bridge Transmission Transmit the buffer that has been recieved on the bridged UART over USB communications device.

Parameters

uart_dev

UART device structure that is bridged

Return values

SD_UART_USB_SUCCESS

on success, error state otherwise

{
    struct sd_cbuf *rxbuff = dev->rx_buff;
    static uint8_t txbuff[CONS_UART_RX_BUFF_SIZE];
    static uint32_t idx;
    uint8_t state;

    while (rxbuff->len && (idx < CONS_UART_RX_BUFF_SIZE)) {
        /* Check for the end of the buffer and wrap */
        if (rxbuff->out >= rxbuff->size)
            rxbuff->out = 0;
    
        /* Put the character in the secondary buffer */
        txbuff[idx++] = rxbuff->buff[rxbuff->out++];
    
        /* Check for the end of the buffer and wrap */
        if (rxbuff->out >= rxbuff->size)
            rxbuff->out = 0;
    
        if (--rxbuff->len <= 0)
            rxbuff->len = 0;
    
        /* Check if the UART interrupt has been triggered and end this loop */
        if ((__HAL_UART_GET_IT(dev->uart, UART_IT_RXNE) != RESET) && 
            (__HAL_UART_GET_IT_SOURCE(dev->uart, UART_IT_RXNE) != RESET))
            return SD_UART_USB_SUCCESS;  /* End the loop here so that the UART can operate */
    }

    /* Transmit if there is anything to transmit */
    if (idx) {
        state = sd_cdc_get_state();
        
        if (state == USBD_STATE_CONFIGURED) {
            sd_cdc_transmit(txbuff, idx);
            idx = 0;    /* Reset the index once we've transmitted */
        }
    }

    return SD_UART_USB_SUCCESS;
}

sd_wl18xx_ant_config()

void sd_wl18xx_ant_config

(

uint8_t

ant

)

#include <Inc/sd_platform.h>

WL18xx Antenna Configuration Outputs antenna select pins for the wireless module.

Parameters

ant	Value defining antenna configuration (two LSBs used)

Return values

None

{
    GPIO_PinState ant_select_1, ant_select_2;
 
    /* Check that the antenna selection is valid */
    if (!IS_WL18xx_ANTENNA_MODE(ant))
        return;

    /* Determine antenna select pins from bits */
    ant_select_1 = (ant & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET;
    ant_select_2 = (ant & 0x02) ? GPIO_PIN_SET : GPIO_PIN_RESET;

    /* Output GPIO selection pins */
    HAL_GPIO_WritePin(ANT_SELECT_1_GPIO_Port, ANT_SELECT_2_Pin,
              ant_select_1);                           
    HAL_GPIO_WritePin(ANT_SELECT_2_GPIO_Port, ANT_SELECT_2_Pin,
              ant_select_2);     
}

sd_wl_clk_enable()

void sd_wl_clk_enable

(

uint8_t

enable

)

#include <Inc/sd_platform.h>

Wireless Clock Enable Enable the wireless module 32kHz clock source.

Parameters

enable

State to set for clock

Return values

None

{
    GPIO_PinState en = enable ? GPIO_PIN_SET : GPIO_PIN_RESET;

    HAL_GPIO_WritePin(WL_32KHZ_CLK_EN_GPIO_Port, 
              WL_32KHZ_CLK_EN_Pin, en);
}

sd_zynq_boot_config()

void sd_zynq_boot_config

(

enum sd_zynq_boot

boot

)

#include <Inc/sd_platform.h>

Zynq Boot Config Outputs boot select pins to zynq for desired boot media source.

Parameters

boot	Value defining boot pin outputs

Return values

None

{
    GPIO_PinState mio4_out, mio5_out;
  
    switch (boot) {
    case SD_ZYNQ_BOOT_JTAG:
        mio4_out = GPIO_PIN_RESET;      /* 0 */
        mio5_out = GPIO_PIN_RESET;      /* 0 */
        break;
    
    case SD_ZYNQ_BOOT_NAND:
        mio4_out = GPIO_PIN_SET;    /* 1 */
        mio5_out = GPIO_PIN_RESET;      /* 0 */
        break;
    
    case SD_ZYNQ_BOOT_QSPI:
        mio4_out = GPIO_PIN_RESET;      /* 0 */
        mio5_out = GPIO_PIN_SET;    /* 1 */
        break;
    
    case SD_ZYNQ_BOOT_SD:
        mio4_out = GPIO_PIN_SET;    /* 1 */
        mio5_out = GPIO_PIN_SET;    /* 1 */
        break;
    }
 
    /* Write boot select pins */
    HAL_GPIO_WritePin(MIO4_BOOT_SELECT_GPIO_Port,
              MIO4_BOOT_SELECT_Pin,
              mio4_out);
    
    HAL_GPIO_WritePin(MIO5_BOOT_SELECT_GPIO_Port, 
              MIO5_BOOT_SELECT_Pin,
              mio5_out);
}

sd_zynq_clk_enable()

void sd_zynq_clk_enable

(

uint8_t

enable

)

#include <Inc/sd_platform.h>

Zynq Clock Enable Enables the main clock source for the Zynq APU.

Parameters

enable

State to set for clock

Return values

None

{
    GPIO_PinState en = enable ? GPIO_PIN_SET : GPIO_PIN_RESET;
    
    HAL_GPIO_WritePin(ZYNQ_CLK_EN_GPIO_Port, 
              ZYNQ_CLK_EN_Pin, en);

}

sd_zynq_disable()

void sd_zynq_disable

(

void

)

#include <Inc/sd_platform.h>

Disable Zynq Power Disable the Zynq power rails by setting the enable pin low.

Parameters

butt	Button used to trigger this function

Return values

None

{
    HAL_GPIO_WritePin(ZYNQ_POWER_EN_GPIO_Port,
                ZYNQ_POWER_EN_Pin, GPIO_PIN_RESET);
    sd_led_rapid(&app_led);
}

sd_zynq_enable()

void sd_zynq_enable

(

void

)

#include <Inc/sd_platform.h>

Enable Zynq Power Enable the Zynq power rails by setting the enable pin high.

Parameters

butt	Button used to trigger this function

Return values

None

{
    HAL_GPIO_WritePin(ZYNQ_POWER_EN_GPIO_Port,
                ZYNQ_POWER_EN_Pin, GPIO_PIN_SET);
                
    sd_led_reset(&app_led);
}

sd_zynq_jtag_enable()

void sd_zynq_jtag_enable

(

uint8_t

enable

)

#include <Inc/sd_platform.h>

Zynq JTAG Enable Enables the JTAG interface for programming the PS or PL.

Parameters

enable

State to set for JTAG interface

Return values

None

{
    GPIO_PinState en = enable ? GPIO_PIN_SET : GPIO_PIN_RESET;

    HAL_GPIO_WritePin(ZYNQ_JTAG_NRST_GPIO_Port, 
              ZYNQ_JTAG_NRST_Pin, en);
}