Permalink
Browse files

Initial smartcard support

  • Loading branch information...
Baldanos committed Oct 20, 2018
1 parent a90979e commit 97ab4b4d11d7f1809a86373cdf3cd80cabac75f1
@@ -212,6 +212,7 @@ static struct cmd_map {
{ T_FLASH, cmd_mode_init },
{ T_WIEGAND, cmd_mode_init },
{ T_LIN, cmd_mode_init },
{ T_SMARTCARD, cmd_mode_init },
{ 0, NULL }
};
@@ -67,6 +67,15 @@ typedef struct {
uint8_t bus_mode;
} uart_config_t;
typedef struct {
uint32_t dev_speed;
uint32_t dev_guard_time;
uint8_t dev_parity;
uint8_t dev_stop_bit;
uint8_t dev_polarity;
uint8_t dev_phase;
} smartcard_config_t;
typedef struct {
mode_dev_gpio_pull_t dev_gpio_pull;
uint32_t dev_speed;
@@ -153,6 +162,7 @@ typedef struct {
uint8_t dev_num;
union {
uart_config_t uart;
smartcard_config_t smartcard;
i2c_config_t i2c;
spi_config_t spi;
jtag_config_t jtag;
@@ -0,0 +1,353 @@
/*
HydraBus/HydraNFC - Copyright (C) 2014-2015 Benjamin VERNOUX
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.
*/
#include "bsp_smartcard.h"
#include "bsp_smartcard_conf.h"
#include "stm32f405xx.h"
#include "stm32f4xx_hal.h"
/*
Warning in order to use this driver all GPIOs peripherals shall be enabled.
*/
#define SMARTCARDx_TIMEOUT_MAX (100000) // About 10sec (see common/chconf.h/CH_CFG_ST_FREQUENCY) can be aborted by UBTN too
#define NB_SMARTCARD (BSP_DEV_SMARTCARD_END)
#define CLOCK_DIV8 (8)
#define CLOCK_DIV16 (16)
static SMARTCARD_HandleTypeDef smartcard_handle[NB_SMARTCARD];
static mode_config_proto_t* smartcard_mode_conf[NB_SMARTCARD];
static volatile uint16_t dummy_read;
/**
* @brief Init low level hardware: GPIO, CLOCK, NVIC...
* @param dev_num: SMARTCARD dev num
* @retval None
*/
/*
This function replaces HAL_SMARTCARD_MspInit() in order to manage multiple devices.
HAL_SMARTCARD_MspInit() shall be empty/not defined
*/
static void smartcard_gpio_hw_init(bsp_dev_smartcard_t dev_num)
{
GPIO_InitTypeDef GPIO_InitStructure;
if(dev_num == BSP_DEV_SMARTCARD1) {
/* Enable the SMARTCARD peripheral */
__USART1_CLK_ENABLE();
GPIO_InitStructure.Mode = GPIO_MODE_AF_OD;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = BSP_SMARTCARD1_GPIO_SPEED;
/* SMARTCARD1 TX pin configuration */
GPIO_InitStructure.Alternate = BSP_SMARTCARD1_AF;
GPIO_InitStructure.Pin = BSP_SMARTCARD1_TX_PIN;
HAL_GPIO_Init(BSP_SMARTCARD1_TX_PORT, &GPIO_InitStructure);
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
/* SMARTCARD1 RX pin configuration */
GPIO_InitStructure.Pin = BSP_SMARTCARD1_CLK_PIN;
HAL_GPIO_Init(BSP_SMARTCARD1_CLK_PORT, &GPIO_InitStructure);
} else {
/* Enable the SMARTCARD peripheral */
__USART2_CLK_ENABLE();
GPIO_InitStructure.Mode = GPIO_MODE_AF_OD;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = BSP_SMARTCARD2_GPIO_SPEED;
/* SMARTCARD2 TX pin configuration */
GPIO_InitStructure.Alternate = BSP_SMARTCARD2_AF;
GPIO_InitStructure.Pin = BSP_SMARTCARD2_TX_PIN;
HAL_GPIO_Init(BSP_SMARTCARD2_TX_PORT, &GPIO_InitStructure);
/* SMARTCARD2 RX pin configuration */
GPIO_InitStructure.Pin = BSP_SMARTCARD2_RX_PIN;
HAL_GPIO_Init(BSP_SMARTCARD2_RX_PORT, &GPIO_InitStructure);
}
}
/**
* @brief DeInit low level hardware: GPIO, CLOCK, NVIC...
* @param dev_num: SMARTCARD dev num
* @retval None
*/
/*
This function replaces HAL_SMARTCARD_MspDeInit() in order to manage multiple devices.
HAL_SMARTCARD_MspDeInit() shall be empty/not defined
*/
static void smartcard_gpio_hw_deinit(bsp_dev_smartcard_t dev_num)
{
if(dev_num == BSP_DEV_SMARTCARD1) {
/* Reset peripherals */
__USART1_FORCE_RESET();
__USART1_RELEASE_RESET();
/* Disable peripherals GPIO */
HAL_GPIO_DeInit(BSP_SMARTCARD1_TX_PORT, BSP_SMARTCARD1_TX_PIN);
HAL_GPIO_DeInit(BSP_SMARTCARD1_CLK_PORT, BSP_SMARTCARD1_CLK_PIN);
} else {
/* Reset peripherals */
__USART2_FORCE_RESET();
__USART2_RELEASE_RESET();
/* Disable peripherals GPIO */
HAL_GPIO_DeInit(BSP_SMARTCARD2_TX_PORT, BSP_SMARTCARD2_TX_PIN);
HAL_GPIO_DeInit(BSP_SMARTCARD2_RX_PORT, BSP_SMARTCARD2_RX_PIN);
}
}
/**
* @brief SMARTCARDx error treatment function.
* @param dev_num: SMARTCARD dev num
* @retval None
*/
static void smartcard_error(bsp_dev_smartcard_t dev_num)
{
if(bsp_smartcard_deinit(dev_num) == BSP_OK) {
/* Re-Initialize the SMARTCARD comunication bus */
bsp_smartcard_init(dev_num, smartcard_mode_conf[dev_num]);
}
}
/**
* @brief Init SMARTCARD device.
* @param dev_num: SMARTCARD dev num.
* @param mode_conf: Mode config proto.
* @retval status: status of the init.
*/
bsp_status_t bsp_smartcard_init(bsp_dev_smartcard_t dev_num, mode_config_proto_t* mode_conf)
{
SMARTCARD_HandleTypeDef* hsmartcard;
bsp_status_t status;
smartcard_mode_conf[dev_num] = mode_conf;
hsmartcard = &smartcard_handle[dev_num];
smartcard_gpio_hw_init(dev_num);
__HAL_SMARTCARD_RESET_HANDLE_STATE(hsmartcard);
if(dev_num == BSP_DEV_SMARTCARD1) {
hsmartcard->Instance = BSP_SMARTCARD1;
} else { /* SMARTCARD2 */
hsmartcard->Instance = BSP_SMARTCARD2;
}
hsmartcard->Init.BaudRate = mode_conf->config.smartcard.dev_speed;
switch(mode_conf->config.smartcard.dev_parity) {
case 1: /* 8/even */
hsmartcard->Init.Parity = SMARTCARD_PARITY_EVEN;
hsmartcard->Init.WordLength = SMARTCARD_WORDLENGTH_9B;
break;
case 2: /* 8/odd */
hsmartcard->Init.Parity = SMARTCARD_PARITY_ODD;
hsmartcard->Init.WordLength = SMARTCARD_WORDLENGTH_9B;
break;
case 0: /* 8/none */
default:
hsmartcard->Init.Parity = SMARTCARD_PARITY_ODD;
hsmartcard->Init.WordLength = SMARTCARD_WORDLENGTH_9B;
break;
}
hsmartcard->Init.Mode = SMARTCARD_MODE_TX_RX;
hsmartcard->Init.Prescaler = 12;
hsmartcard->Init.GuardTime = 16;
hsmartcard->Init.NACKState = SMARTCARD_NACK_ENABLE;
hsmartcard->Init.CLKLastBit = SMARTCARD_LASTBIT_ENABLE;
if(mode_conf->config.smartcard.dev_stop_bit == 1)
hsmartcard->Init.StopBits = SMARTCARD_STOPBITS_1_5;
else
hsmartcard->Init.StopBits = SMARTCARD_STOPBITS_0_5;
if(mode_conf->config.smartcard.dev_phase == 0)
hsmartcard->Init.CLKPhase = SMARTCARD_PHASE_1EDGE;
else
hsmartcard->Init.CLKPhase = SMARTCARD_PHASE_2EDGE;
if(mode_conf->config.smartcard.dev_polarity == 0)
hsmartcard->Init.CLKPolarity = SMARTCARD_POLARITY_LOW;
else
hsmartcard->Init.CLKPolarity = SMARTCARD_POLARITY_HIGH;
status = HAL_SMARTCARD_Init(hsmartcard);
/* Dummy read to flush old character */
dummy_read = hsmartcard->Instance->DR;
return status;
}
/**
* @brief De-initialize the SMARTCARD comunication bus
* @param dev_num: SMARTCARD dev num.
* @retval status: status of the deinit.
*/
bsp_status_t bsp_smartcard_deinit(bsp_dev_smartcard_t dev_num)
{
SMARTCARD_HandleTypeDef* hsmartcard;
bsp_status_t status;
hsmartcard = &smartcard_handle[dev_num];
/* De-initialize the SMARTCARD comunication bus */
status = HAL_SMARTCARD_DeInit(hsmartcard);
/* DeInit the low level hardware: GPIO, CLOCK, NVIC... */
smartcard_gpio_hw_deinit(dev_num);
return status;
}
/**
* @brief Sends a Byte in blocking mode and return the status.
* @param dev_num: SMARTCARD dev num.
* @param tx_data: data to send.
* @param nb_data: Number of data to send.
* @retval status of the transfer.
*/
bsp_status_t bsp_smartcard_write_u8(bsp_dev_smartcard_t dev_num, uint8_t* tx_data, uint8_t nb_data)
{
SMARTCARD_HandleTypeDef* hsmartcard;
hsmartcard = &smartcard_handle[dev_num];
bsp_status_t status;
status = HAL_SMARTCARD_Transmit(hsmartcard, tx_data, nb_data, SMARTCARDx_TIMEOUT_MAX);
if(status != BSP_OK) {
smartcard_error(dev_num);
}
return status;
}
/**
* @brief Read a Byte in blocking mode and return the status.
* @param dev_num: SMARTCARD dev num.
* @param rx_data: Data to receive.
* @param nb_data: Number of data to receive.
* @retval status of the transfer.
*/
bsp_status_t bsp_smartcard_read_u8(bsp_dev_smartcard_t dev_num, uint8_t* rx_data, uint8_t nb_data)
{
SMARTCARD_HandleTypeDef* hsmartcard;
hsmartcard = &smartcard_handle[dev_num];
bsp_status_t status;
status = HAL_SMARTCARD_Receive(hsmartcard, rx_data, nb_data, SMARTCARDx_TIMEOUT_MAX);
if(status != BSP_OK) {
smartcard_error(dev_num);
}
return status;
}
/**
* @brief Read bytes in blocking mode, with timeout
* @param dev_num: SMARTCARD dev num.
* @param rx_data: Data to receive.
* @param nb_data: Number of data to receive.
* @param timeout: Number of ticks to wait
* @retval Number of bytes read
*/
bsp_status_t bsp_smartcard_read_u8_timeout(bsp_dev_smartcard_t dev_num, uint8_t* rx_data,
uint8_t nb_data, uint32_t timeout)
{
SMARTCARD_HandleTypeDef* hsmartcard;
hsmartcard = &smartcard_handle[dev_num];
bsp_status_t status;
status = HAL_SMARTCARD_Receive(hsmartcard, rx_data, nb_data, timeout);
switch(status){
case BSP_OK:
case BSP_TIMEOUT:
return (nb_data-(hsmartcard->RxXferCount)-1);
case BSP_ERROR:
default:
smartcard_error(dev_num);
return 0;
}
}
/**
* @brief Send a byte then Read a byte through the SMARTCARD interface.
* @param tx_data: Data to send.
* @param rx_data: Data to receive.
* @param nb_data: Number of data to send & receive.
* @retval status of the transfer.
*/
bsp_status_t bsp_smartcard_write_read_u8(bsp_dev_smartcard_t dev_num, uint8_t* tx_data, uint8_t* rx_data, uint8_t nb_data)
{
SMARTCARD_HandleTypeDef* hsmartcard;
hsmartcard = &smartcard_handle[dev_num];
bsp_status_t status;
status = HAL_SMARTCARD_Transmit(hsmartcard, tx_data, nb_data, SMARTCARDx_TIMEOUT_MAX);
if(status == BSP_OK) {
status = HAL_SMARTCARD_Receive(hsmartcard, rx_data, nb_data, SMARTCARDx_TIMEOUT_MAX);
} else {
smartcard_error(dev_num);
}
return status;
}
/**
* @brief Checks if the SMARTCARD receive buffer is empty
* @retval 0 if empty, 1 if data
*/
bsp_status_t bsp_smartcard_rxne(bsp_dev_smartcard_t dev_num)
{
SMARTCARD_HandleTypeDef* hsmartcard;
hsmartcard = &smartcard_handle[dev_num];
return __HAL_SMARTCARD_GET_FLAG(hsmartcard, SMARTCARD_FLAG_RXNE);
}
/** \brief Return final baud rate configured for over8=0 or over8=1.
*
* \param dev_num bsp_dev_smartcard_t
* \return uint32_t final baudrate configured
*
*/
uint32_t bsp_smartcard_get_final_baudrate(bsp_dev_smartcard_t dev_num)
{
float f_baudrate;
float f_baudrate_frac;
uint32_t final_baudrate;
uint32_t clock;
uint32_t brr;
SMARTCARD_HandleTypeDef* hsmartcard;
hsmartcard = &smartcard_handle[dev_num];
brr = hsmartcard->Instance->BRR;
if((hsmartcard->Instance == USART1) || (hsmartcard->Instance == USART6))
clock = HAL_RCC_GetPCLK2Freq() / CLOCK_DIV16;
else
clock = HAL_RCC_GetPCLK1Freq() / CLOCK_DIV16;
final_baudrate = brr >> 4;
if(final_baudrate > 0) {
f_baudrate_frac = (float)(brr & 0x0F) / 16.0f;
f_baudrate = ((float)final_baudrate) + f_baudrate_frac;
final_baudrate = (uint32_t)((float)clock / f_baudrate);
}
return final_baudrate;
}
Oops, something went wrong.

0 comments on commit 97ab4b4

Please sign in to comment.