embox

1
/**
2
 * @file
3
 * @brief
4
 *
5
 * @author  Anton Kozlov
6
 * @date    06.08.2014
7
 */
8

9
#include <stdint.h>
10
#include <string.h>
11

12
#include <drivers/serial/diag_serial.h>
13

14
#include <drivers/serial/stm_usart.h>
15

16
#include <drivers/serial/uart_dev.h>
17

18
static int stm32_uart_putc(struct uart *dev, int ch) {
19
	USART_TypeDef *uart = (void *) dev->base_addr;
20

21
	while ((STM32_USART_FLAGS(uart) & USART_FLAG_TXE) == 0);
22

23
	STM32_USART_TXDATA(uart) = (uint8_t) ch;
24

25
	return 0;
26
}
27

28
static int stm32_uart_hasrx(struct uart *dev) {
29
	USART_TypeDef *uart = (void *) dev->base_addr;
30

31
	/* Clear possible Overruns. It can happen, for example,
32
	 * when start scripts executed and you press buttons at the same time. */
33
	STM32_USART_CLEAR_ORE(uart);
34

35
	return STM32_USART_FLAGS(uart) & USART_FLAG_RXNE;
36
}
37

38
static int stm32_uart_getc(struct uart *dev) {
39
	USART_TypeDef *uart = (void *) dev->base_addr;
40

41
	return (uint8_t)(STM32_USART_RXDATA(uart) & 0xFF);
42
}
43

44
static void stm32cube_fill_uart_init_param(const struct uart_params *params, UART_InitTypeDef *init) {
45
	uint32_t flags;
46
	
47
	flags = params->uart_param_flags;
48

49
	switch (UART_PARAM_FLAGS_PARITY_MASK(flags)) {
50
		case UART_PARAM_FLAGS_PARITY_ODD:
51
			init->Parity = UART_PARITY_ODD;
52
			break;
53
		case UART_PARAM_FLAGS_PARITY_EVEN:
54
			init->Parity = UART_PARITY_EVEN;
55
			break;
56
		case UART_PARAM_FLAGS_PARITY_NONE:
57
		default:
58
			init->Parity = UART_PARITY_NONE;
59
			break;
60
	}
61

62
	switch (UART_PARAM_FLAGS_BIT_WORD_MASK(flags)) {
63
#if defined (UART_WORDLENGTH_7B)
64
		case UART_PARAM_FLAGS_7BIT_WORD:
65
			init->WordLength = UART_WORDLENGTH_7B;
66
			break;
67
#endif
68
		case UART_PARAM_FLAGS_9BIT_WORD:
69
			init->WordLength = UART_WORDLENGTH_9B;
70
			break;
71
		case UART_PARAM_FLAGS_8BIT_WORD:
72
		default:
73
			init->WordLength = UART_WORDLENGTH_8B;
74
			break;
75
	}
76

77

78
	switch (UART_PARAM_FLAGS_STOPS_MASK(flags)) {
79
#if defined (UART_STOPBITS_0_5)
80
		case UART_PARAM_FLAGS_0_5_STOP:
81
			init->StopBits = UART_STOPBITS_0_5;
82
			break;
83
#endif
84
#if defined (UART_STOPBITS_1_5)
85
		case UART_PARAM_FLAGS_1_5_STOP:
86
			init->StopBits = UART_STOPBITS_1_5;
87
			break;
88
#endif
89
		case UART_PARAM_FLAGS_2_STOP:
90
			init->StopBits = UART_STOPBITS_2;
91
			break;
92
		case UART_PARAM_FLAGS_1_STOP:
93
		default:
94
			init->StopBits = UART_STOPBITS_1;
95
			break;
96
	}
97

98
	switch (UART_PARAM_FLAGS_HWCTRL_MASK(flags)) {
99
		case UART_PARAM_FLAGS_HWCRTL_CTS:
100
			init->HwFlowCtl = UART_HWCONTROL_CTS;
101
			break;
102
		case UART_PARAM_FLAGS_HWCRTL_RTS:
103
			init->HwFlowCtl = UART_HWCONTROL_RTS;
104
			break;
105
		case UART_PARAM_FLAGS_HWCRTL_BOTH:
106
			init->HwFlowCtl = UART_HWCONTROL_RTS_CTS;
107
			break;
108
		case UART_PARAM_FLAGS_HWCRTL_NONE:
109
		default:
110
			init->HwFlowCtl = UART_HWCONTROL_NONE;
111
			break;
112
	}
113

114
	init->BaudRate = params->baud_rate;
115
	init->Mode = UART_MODE_TX_RX;
116

117
}
118

119
static int stm32_uart_setup(struct uart *dev, const struct uart_params *params) {
120
	UART_HandleTypeDef UartHandle;
121

122
	memset(&UartHandle, 0, sizeof(UartHandle));
123

124
	UartHandle.Instance = (void*) dev->base_addr;
125

126
	stm32cube_fill_uart_init_param(params, &UartHandle.Init);
127

128
	if (HAL_UART_Init(&UartHandle) != HAL_OK) {
129
		return -1;
130
	}
131

132
	if (dev->params.uart_param_flags & UART_PARAM_FLAGS_USE_IRQ) {
133
	    /* Enable the UART Data Register not empty Interrupt */
134
	    __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
135
	}
136

137
	return 0;
138
}
139

140
static int stm32_uart_irq_en(struct uart *dev, const struct uart_params *params) {
141
	if (params->uart_param_flags & UART_PARAM_FLAGS_USE_IRQ) {
142
		UART_HandleTypeDef UartHandle;
143

144
		memset(&UartHandle, 0, sizeof(UartHandle));
145

146
		UartHandle.Instance = (void*) dev->base_addr;
147

148
		stm32cube_fill_uart_init_param(params, &UartHandle.Init);
149
	
150
	    /* Enable the UART Data Register not empty Interrupt */
151
	    __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
152
	}
153
	return 0;
154
}
155

156
static int stm32_uart_irq_dis(struct uart *dev, const struct uart_params *params) {
157
	if (params->uart_param_flags & UART_PARAM_FLAGS_USE_IRQ) {
158
		UART_HandleTypeDef UartHandle;
159

160
		memset(&UartHandle, 0, sizeof(UartHandle));
161

162
		UartHandle.Instance = (void*) dev->base_addr;
163

164
		stm32cube_fill_uart_init_param(params, &UartHandle.Init);
165

166
		__HAL_UART_DISABLE_IT(&UartHandle, UART_IT_RXNE);
167
	}
168
	return 0;
169
}
170

171
const struct uart_ops stm32_uart_ops = {
172
		.uart_getc = stm32_uart_getc,
173
		.uart_putc = stm32_uart_putc,
174
		.uart_hasrx = stm32_uart_hasrx,
175
		.uart_setup = stm32_uart_setup,
176
		.uart_irq_en = stm32_uart_irq_en,
177
		.uart_irq_dis = stm32_uart_irq_dis,
178
};
179