/
zOMGdev
/
embox
GigaCode
beta
ОбзорЦентр заботыВойти

embox

Форк
0
Ветки: 43Коммиты: 25969Теги: 64
embox
/src
/drivers
/serial
/mikron_usart
/
mikron_usart.c 
274 строки · 9.5 Кб
1
/**
2
 * @file
3


4
 * @date 01 june  2024
5
 * @author: Anton Bondarev
6
 */
7
#include <stdint.h>
8


9
#include <drivers/serial/uart_dev.h>
10
#include <framework/mod/options.h>
11
#include <hal/reg.h>
12


13
#include <drivers/gpio/gpio.h>
14
#include <drivers/gpio/mikron_gpio.h>
15


16
#include <config/board_config.h>
17


18
#define SYSFREQ         32000000 /* 32MHz*/
19
#define USE_BOARD_CONF  OPTION_GET(BOOLEAN, use_bconf)
20


21
#if USE_BOARD_CONF
22
#include "uart_setup_hw_board_config.inc"
23
#else
24
static inline int uart_setup_hw(struct uart *dev) {
25
	gpio_setup_mode(GPIO_PORT_B, 1 << 8, GPIO_MODE_OUT_ALTERNATE | GPIO_ALTERNATE(0x1));
26
	gpio_setup_mode(GPIO_PORT_B, 1 << 9, GPIO_MODE_OUT_ALTERNATE | GPIO_ALTERNATE(0x1));
27
	return 0;
28
}
29
#endif /* USE_BOARD_CONF */
30


31
#define UART_CONTROL1_M1_S         28
32
#define UART_CONTROL1_M1_M         (1 << UART_CONTROL1_M1_S)
33
#define UART_CONTROL1_M0_S         12
34
#define UART_CONTROL1_M0_M         (1 << UART_CONTROL1_M0_S)
35
#define UART_CONTROL1_M_8BIT_M     (0)
36
#define UART_CONTROL1_M_9BIT_M     (UART_CONTROL1_M0_M)
37
#define UART_CONTROL1_M_7BIT_M     (UART_CONTROL1_M1_M)
38
#define UART_CONTROL1_M_M          (UART_CONTROL1_M1_M | UART_CONTROL1_M0_M)
39
#define UART_CONTROL1_M(V)         (((((v) / 10) << UART_CONTROL1_M1_S) | (((v) % 10) << UART_CONTROL1_M0_S)) & UART_CONTROL1_M_M)
40
#define UART_CONTROL1_PCE_S        10
41
#define UART_CONTROL1_PCE_M        (1 << UART_CONTROL1_PCE_S)
42
#define UART_CONTROL1_PS_S         9
43
#define UART_CONTROL1_PS_M         (1 << UART_CONTROL1_PS_S)
44
#define UART_CONTROL1_PEIE_S       8
45
#define UART_CONTROL1_PEIE_M       (1 << UART_CONTROL1_PEIE_S)
46
#define UART_CONTROL1_TXEIE_S      7
47
#define UART_CONTROL1_TXEIE_M      (1 << UART_CONTROL1_TXEIE_S)
48
#define UART_CONTROL1_TCIE_S       6
49
#define UART_CONTROL1_TCIE_M       (1 << UART_CONTROL1_TCIE_S)
50
#define UART_CONTROL1_RXNEIE_S     5
51
#define UART_CONTROL1_RXNEIE_M     (1 << UART_CONTROL1_RXNEIE_S)
52
#define UART_CONTROL1_IDLEIE_S     4
53
#define UART_CONTROL1_IDLEIE_M     (1 << UART_CONTROL1_IDLEIE_S)
54
#define UART_CONTROL1_TE_S         3
55
#define UART_CONTROL1_TE_M         (1 << UART_CONTROL1_TE_S)
56
#define UART_CONTROL1_RE_S         2
57
#define UART_CONTROL1_RE_M         (1 << UART_CONTROL1_RE_S)
58
#define UART_CONTROL1_UE_S         0
59
#define UART_CONTROL1_UE_M         (1 << UART_CONTROL1_UE_S)
60


61
#define UART_CONTROL2_MSBFIRST_S   19
62
#define UART_CONTROL2_MSBFIRST_M   (1 << UART_CONTROL2_MSBFIRST_S)
63
#define UART_CONTROL2_DATAINV_S    18
64
#define UART_CONTROL2_DATAINV_M    (1 << UART_CONTROL2_DATAINV_S)
65
#define UART_CONTROL2_TXINV_S      17
66
#define UART_CONTROL2_TXINV_M      (1 << UART_CONTROL2_TXINV_S)
67
#define UART_CONTROL2_RXINV_S      16
68
#define UART_CONTROL2_RXINV_M      (1 << UART_CONTROL2_RXINV_S)
69
#define UART_CONTROL2_SWAP_S       15
70
#define UART_CONTROL2_SWAP_M       (1 << UART_CONTROL2_SWAP_S)
71
#define UART_CONTROL2_LBM_S        14
72
#define UART_CONTROL2_LBM_M        (1 << UART_CONTROL2_LBM_S)
73
#define UART_CONTROL2_STOP_1_S     13
74
#define UART_CONTROL2_STOP_1_M     (1 << UART_CONTROL2_STOP_1_S)
75
#define UART_CONTROL2_CLKEN_S      11
76
#define UART_CONTROL2_CLKEN_M      (1 << UART_CONTROL2_CLKEN_S)
77
#define UART_CONTROL2_CPOL_S       10
78
#define UART_CONTROL2_CPOL_M       (1 << UART_CONTROL2_CPOL_S)
79
#define UART_CONTROL2_CPHA_S       9
80
#define UART_CONTROL2_CPHA_M       (1 << UART_CONTROL2_CPHA_S)
81
#define UART_CONTROL2_LBCL_S       8
82
#define UART_CONTROL2_LBCL_M       (1 << UART_CONTROL2_LBCL_S)
83
#define UART_CONTROL2_LBDIE_S      6    
84
#define UART_CONTROL2_LBDIE_M      (1 << UART_CONTROL2_LBDIE_S)
85


86
#define UART_CONTROL3_OVRDIS_S     12
87
#define UART_CONTROL3_OVRDIS_M     (1 << UART_CONTROL3_OVRDIS_S)
88
#define UART_CONTROL3_CTSIE_S      10
89
#define UART_CONTROL3_CTSIE_M      (1 << UART_CONTROL3_CTSIE_S)
90
#define UART_CONTROL3_CTSE_S       9
91
#define UART_CONTROL3_CTSE_M       (1 << UART_CONTROL3_CTSE_S)
92
#define UART_CONTROL3_RTSE_S       8
93
#define UART_CONTROL3_RTSE_M       (1 << UART_CONTROL3_RTSE_S)
94
#define UART_CONTROL3_DMAT_S       7
95
#define UART_CONTROL3_DMAT_M       (1 << UART_CONTROL3_DMAT_S)
96
#define UART_CONTROL3_DMAR_S       6
97
#define UART_CONTROL3_DMAR_M       (1 << UART_CONTROL3_DMAR_S)
98
#define UART_CONTROL3_HDSEL_S      3
99
#define UART_CONTROL3_HDSEL_M      (1 << UART_CONTROL3_HDSEL_S)
100
#define UART_CONTROL3_BKRQ_S       2
101
#define UART_CONTROL3_BKRQ_M       (1 << UART_CONTROL3_BKRQ_S)
102
// #define UART_CONTROL3_IREN_S       1
103
// #define UART_CONTROL3_IREN_M       (1 << UART_CONTROL3_IREN_S)
104
#define UART_CONTROL3_EIE_S        0
105
#define UART_CONTROL3_EIE_M        (1 << UART_CONTROL3_EIE_S)
106


107
#define UART_DIVIDER_BRR_S        0
108
#define UART_DIVIDER_BRR_M        (0xFFFF << UART_DIVIDER_BRR_S)
109


110
#define UART_FLAGS_REACK_S         22
111
#define UART_FLAGS_REACK_M         (1 << UART_FLAGS_REACK_S)
112
#define UART_FLAGS_TEACK_S         21
113
#define UART_FLAGS_TEACK_M         (1 << UART_FLAGS_TEACK_S)
114
#define UART_FLAGS_BUSY_S          16
115
#define UART_FLAGS_BUSY_M          (1 << UART_FLAGS_BUSY_S)
116
#define UART_FLAGS_CTS_S           10
117
#define UART_FLAGS_CTS_M           (1 << UART_FLAGS_CTS_S)
118
#define UART_FLAGS_CTSIF_S         9
119
#define UART_FLAGS_CTSIF_M         (1 << UART_FLAGS_CTSIF_S)
120
#define UART_FLAGS_LBDF_S          8
121
#define UART_FLAGS_LBDF_M          (1 << UART_FLAGS_LBDF_S)
122
#define UART_FLAGS_TXE_S           7
123
#define UART_FLAGS_TXE_M           (1 << UART_FLAGS_TXE_S)
124
#define UART_FLAGS_TC_S            6
125
#define UART_FLAGS_TC_M            (1 << UART_FLAGS_TC_S)
126
#define UART_FLAGS_RXNE_S          5
127
#define UART_FLAGS_RXNE_M          (1 << UART_FLAGS_RXNE_S)
128
#define UART_FLAGS_IDLE_S          4
129
#define UART_FLAGS_IDLE_M          (1 << UART_FLAGS_IDLE_S)
130
#define UART_FLAGS_ORE_S           3
131
#define UART_FLAGS_ORE_M           (1 << UART_FLAGS_ORE_S)
132
#define UART_FLAGS_NF_S            2
133
#define UART_FLAGS_NF_M            (1 << UART_FLAGS_NF_S)
134
#define UART_FLAGS_FE_S            1
135
#define UART_FLAGS_FE_M            (1 << UART_FLAGS_FE_S)
136
#define UART_FLAGS_PE_S            0
137
#define UART_FLAGS_PE_M            (1 << UART_FLAGS_PE_S)
138


139
#define UART_MODEM_DTR_S           8
140
#define UART_MODEM_DTR_M           (1 << UART_MODEM_DTR_S)
141
#define UART_MODEM_DCD_S           7
142
#define UART_MODEM_DCD_M           (1 << UART_MODEM_DCD_S)
143
#define UART_MODEM_RI_S            6
144
#define UART_MODEM_RI_M            (1 << UART_MODEM_RI_S)
145
#define UART_MODEM_DSR_S           5
146
#define UART_MODEM_DSR_M           (1 << UART_MODEM_DSR_S)
147
#define UART_MODEM_DCDIF_S         3
148
#define UART_MODEM_DCDIF_M         (1 << UART_MODEM_DCDIF_S)
149
#define UART_MODEM_RIIF_S          2
150
#define UART_MODEM_RIIF_M          (1 << UART_MODEM_RIIF_S)
151
#define UART_MODEM_DSRIF_S         1
152
#define UART_MODEM_DSRIF_M         (1 << UART_MODEM_DSRIF_S)
153


154
struct mikron_uart_regs {
155
	volatile uint32_t CONTROL1;
156
	volatile uint32_t CONTROL2;
157
	volatile uint32_t CONTROL3;
158
	volatile uint32_t DIVIDER;
159
	volatile uint32_t _reserved0;
160
	volatile uint32_t _reserved1;
161
	volatile uint32_t _reserved2;
162
	volatile uint32_t FLAGS;
163
	volatile uint32_t _reserved3;
164
	volatile uint32_t RXDATA;
165
	volatile uint32_t TXDATA;
166
	volatile uint32_t MODEM;
167
};
168


169
static void mikron_usart_set_baudrate(struct uart *dev) {
170
	uint32_t divider = SYSFREQ / dev->params.baud_rate;
171
	struct mikron_uart_regs *regs;
172


173
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
174


175
	REG32_STORE(&regs->DIVIDER, divider); 
176
}
177


178
static int mikron_usart_irq_enable(struct uart *dev, 
179
									const struct uart_params *params) {
180
	struct mikron_uart_regs *regs;
181


182
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
183


184
	if (params->uart_param_flags & UART_PARAM_FLAGS_USE_IRQ) {
185
		REG32_ORIN(&regs->CONTROL1, UART_CONTROL1_RXNEIE_M);
186
	}
187


188
	return 0;
189
}
190


191
static int mikron_usart_irq_disable(struct uart *dev,
192
									const struct uart_params *params) {
193
	struct mikron_uart_regs *regs;
194


195
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
196


197
	REG32_ANDIN(&regs->CONTROL1, ~UART_CONTROL1_RXNEIE_M);
198


199
	return 0;
200
}
201


202
static int mikron_usart_setup(struct uart *dev, 
203
								const struct uart_params *params) {
204
	uint32_t ctrl;
205
	uint32_t flags;
206
	struct mikron_uart_regs *regs;
207


208
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
209


210
	ctrl = UART_CONTROL1_TE_M | UART_CONTROL1_RE_M | UART_CONTROL1_M_8BIT_M;
211
	if (params->uart_param_flags & UART_PARAM_FLAGS_8BIT_WORD) {
212
		ctrl |= UART_CONTROL1_M_8BIT_M;		
213
	}
214
	ctrl |= UART_CONTROL1_UE_M;
215


216
	/* Disable uart. */
217
	REG32_STORE(&regs->CONTROL1, 0);
218
	REG32_STORE(&regs->CONTROL2, 0);
219
	REG32_STORE(&regs->CONTROL3, 0);
220
	REG32_STORE(&regs->FLAGS, 0xFFFFFFFF);
221


222
	uart_setup_hw(dev);
223
	
224
	mikron_usart_set_baudrate(dev);
225


226
	REG32_STORE(&regs->CONTROL1, ctrl);
227


228
	mikron_usart_irq_enable(dev, params);
229


230
	flags = 0;
231
	do {
232
		flags = REG32_LOAD(&regs->FLAGS);
233
	} while(!(flags & UART_FLAGS_REACK_M) && !(flags | UART_FLAGS_TEACK_M));
234


235
	return 0;
236
}
237


238
static int mikron_usart_putc(struct uart *dev, int ch) {
239
	struct mikron_uart_regs *regs;
240
	
241
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
242


243
	while ( 0 == (REG_LOAD(&regs->FLAGS) & UART_FLAGS_TXE_M)) {
244
	}
245


246
	REG32_STORE(&regs->TXDATA, ch);
247


248
	return 0;
249
}
250


251
static int mikron_usart_has_symbol(struct uart *dev) {
252
	struct mikron_uart_regs *regs;
253


254
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
255


256
	return (REG_LOAD(&regs->FLAGS) & UART_FLAGS_RXNE_M) ? 1 :0 ;
257
}
258


259
static int mikron_usart_getc(struct uart *dev) {
260
	struct mikron_uart_regs *regs;
261


262
	regs = (struct mikron_uart_regs *)(uintptr_t) dev->base_addr;
263


264
	return REG_LOAD(&regs->RXDATA) & 0xFF;
265
}
266


267
const struct uart_ops mikron_usart_ops = {
268
    .uart_getc = mikron_usart_getc,
269
    .uart_putc = mikron_usart_putc,
270
    .uart_hasrx = mikron_usart_has_symbol,
271
    .uart_setup = mikron_usart_setup,
272
    .uart_irq_en = mikron_usart_irq_enable,
273
    .uart_irq_dis = mikron_usart_irq_disable,
274
};
275

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.