]> git.cryptolib.org Git - arm-crypto-lib.git/blob - test_src/uart_lowlevel.c
a0b5091fc9a9894017f76a51a67981acdc615861
[arm-crypto-lib.git] / test_src / uart_lowlevel.c
1 /* uart_lowlevel.c */
2 /*
3     This file is part of the AVR-Crypto-Lib.
4     Copyright (C) 2010 Daniel Otte (daniel.otte@rub.de)
5
6     This program is free software: you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation, either version 3 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <stdint.h>
21 #include "sysclock.h"
22 #include "hw_regs.h"
23 #include "hw_uart_regs.h"
24 #include "uart_defines.h"
25
26 void calc_baud_values(uint32_t baudrate, uint16_t* intdivider, uint8_t* fracdivider, uint8_t* highspeed){
27         uint32_t tmp;
28         uint32_t uart_freq;
29         uart_freq = sysclk_get_freq();
30         *highspeed = (baudrate*16>uart_freq)?1:0;
31         tmp = (uint64_t)uart_freq*128/((*highspeed?8:16)*baudrate);
32         tmp++;
33         tmp>>=1;
34         *fracdivider = (uint8_t)(tmp&0x3f);
35         *intdivider = tmp>>6;
36 }
37
38 static const
39 uint32_t uart_base[] = { UART0_BASE, UART1_BASE, UART2_BASE };
40
41 static const
42 uint32_t gpio_base[] =
43         { GPIOA_BASE, GPIOB_BASE, GPIOC_BASE, GPIOD_BASE,
44           GPIOE_BASE, GPIOF_BASE, GPIOG_BASE, GPIOH_BASE,
45           GPIOJ_BASE,
46         };
47
48 static const
49 uint8_t uart_tx_gpio[] = { GPIOA, GPIOD, GPIOG };
50 static const
51 uint8_t uart_rx_gpio[] = { GPIOA, GPIOD, GPIOG };
52 static const
53 uint8_t uart_tx_pin[] = { 1, 1, 1 };
54 static const
55 uint8_t uart_rx_pin[] = { 0, 0, 0 };
56 static const
57 uint8_t uart_tx_pctl[] = {1, 5, 1};
58 static const
59 uint8_t uart_rx_pctl[] = {1, 5, 1};
60
61 uint8_t uart_init(uint8_t uartno, uint32_t baudrate, uint8_t databits, uint8_t paraty, uint8_t stopbits){
62         uint32_t tmp;
63         if(databits>=5){
64                 databits-=5;
65         }
66         if(uartno>UART_MAX){
67                 return UART_ERROR_WRONG_UART;
68         }
69         if(databits>UART_DATABITS_8){
70                 return UART_ERROR_WRONG_DATABITS;
71         }
72         if(paraty>UART_PARATY_SPACE){
73                 return UART_ERROR_WRONG_PARATY;
74         }
75         if(stopbits>UART_STOPBITS_TWO){
76                 return UART_ERROR_WRONG_STOPBITS;
77         }
78         /* enable clock for uart */
79         HW_REG(SYSCTL_BASE+RCGC1_OFFSET) |= _BV(uartno);
80         /* enable clock for gpio*/
81         HW_REG(SYSCTL_BASE+RCGC2_OFFSET) |= _BV(uart_rx_gpio[uartno]) | _BV(uart_tx_gpio[uartno]);
82     HW_REG(SYSCTL_BASE+RCGC2_OFFSET) |= 1;
83
84     HW_REG(gpio_base[uart_rx_gpio[uartno]] + GPIO_ODR_OFFSET) &= ~_BV(uart_rx_pin[uartno]); /* open drain */
85     HW_REG(gpio_base[uart_tx_gpio[uartno]] + GPIO_ODR_OFFSET) &= ~_BV(uart_tx_pin[uartno]); /* open drain */
86     HW_REG(gpio_base[uart_rx_gpio[uartno]] + GPIO_PUR_OFFSET) &= ~_BV(uart_rx_pin[uartno]); /* pull-up */
87     HW_REG(gpio_base[uart_tx_gpio[uartno]] + GPIO_PUR_OFFSET) &= ~_BV(uart_tx_pin[uartno]); /* pull-up */
88     HW_REG(gpio_base[uart_rx_gpio[uartno]] + GPIO_PDR_OFFSET) &= ~_BV(uart_rx_pin[uartno]); /* pull-down*/
89     HW_REG(gpio_base[uart_tx_gpio[uartno]] + GPIO_PDR_OFFSET) &= ~_BV(uart_tx_pin[uartno]); /* pull-down*/
90     HW_REG(gpio_base[uart_rx_gpio[uartno]] + GPIO_DEN_OFFSET) |=  _BV(uart_rx_pin[uartno]); /* digital enable */
91     HW_REG(gpio_base[uart_tx_gpio[uartno]] + GPIO_DEN_OFFSET) |=  _BV(uart_tx_pin[uartno]); /* digital enable */
92
93         /* switch to alternate function for rx */
94         HW_REG(gpio_base[uart_rx_gpio[uartno]]+GPIO_AFSEL_OFFSET) |= _BV(uart_rx_pin[uartno]);
95          /* switch to alternate function for tx */
96         HW_REG(gpio_base[uart_tx_gpio[uartno]]+GPIO_AFSEL_OFFSET) |= _BV(uart_tx_pin[uartno]);
97         /* switch multiplexer to uart for rx */
98         HW_REG(gpio_base[uart_rx_gpio[uartno]]+GPIO_PCTL_OFFSET) &= ~(0x0f<<(uart_rx_pin[uartno]*4));
99         HW_REG(gpio_base[uart_rx_gpio[uartno]]+GPIO_PCTL_OFFSET) |= ((uart_rx_pctl[uartno])<<(uart_rx_pin[uartno]*4));
100         /* switch multiplexer to uart for tx */
101         HW_REG(gpio_base[uart_tx_gpio[uartno]]+GPIO_PCTL_OFFSET) &= ~(0x0f<<(uart_tx_pin[uartno]*4));
102         HW_REG(gpio_base[uart_tx_gpio[uartno]]+GPIO_PCTL_OFFSET) |= ((uart_tx_pctl[uartno])<<(uart_tx_pin[uartno]*4));
103         /* set pins to be 2mA */
104         HW_REG(gpio_base[uart_rx_gpio[uartno]]+GPIO_DR2R_OFFSET) |= _BV(uart_rx_pin[uartno]);
105         HW_REG(gpio_base[uart_tx_gpio[uartno]]+GPIO_DR2R_OFFSET) |= _BV(uart_tx_pin[uartno]);
106         /* configure rx pin as input */
107         HW_REG(gpio_base[uart_rx_gpio[uartno]]+GPIO_DIR_OFFSET) &= ~_BV(uart_rx_pin[uartno]);
108         /* configure tx pin as output */
109         HW_REG(gpio_base[uart_tx_gpio[uartno]]+GPIO_DIR_OFFSET) |= _BV(uart_tx_pin[uartno]);
110
111         /* disable uart */
112         HW_REG(uart_base[uartno]+UARTCTL_OFFSET) &= ~_BV(UARTEN);
113         /* set baudrate parameters */
114         uint8_t highspeed;
115         calc_baud_values(baudrate,
116                                  (uint16_t*)&HW_REG(uart_base[uartno]+UARTIBRD_OFFSET),
117                                  (uint8_t*)&HW_REG(uart_base[uartno]+UARTFBRD_OFFSET),
118                                  &highspeed);
119         /* wait until uart is no longer busy */
120         while(HW_REG(uart_base[uartno]+UARTFR_OFFSET)&_BV(UART_BUSY))
121                 ;
122         /* flush FIFOs */
123         HW_REG(uart_base[uartno]+UARTLCRH_OFFSET) &= ~_BV(UART_FEN);
124         /* set line parameters (bits, paraty, stopbits*/
125         tmp = HW_REG(uart_base[uartno]+UARTLCRH_OFFSET);
126         tmp &= ~0xff;
127         tmp |= (paraty==UART_PARATY_MARK||paraty==UART_PARATY_SPACE)?_BV(7):0; /* set flag for mark or space paraty*/
128         tmp |= databits<<5;
129         tmp |= _BV(UART_FEN); /* enable FIFOs */
130         tmp |= (stopbits==UART_STOPBITS_TWO)?_BV(3):0;
131         tmp |= (paraty==UART_PARATY_EVEN || paraty==UART_PARATY_MARK)?_BV(2):0;
132         tmp |= (paraty!=UART_PARATY_NONE)?_BV(1):0;
133         HW_REG(uart_base[uartno]+UARTLCRH_OFFSET) = tmp;
134         /* set the highspeed bit accordingly */
135         if(highspeed){
136                 HW_REG(uart_base[uartno]+UARTCTL_OFFSET) |= _BV(UART_HSE);
137         } else {
138                 HW_REG(uart_base[uartno]+UARTCTL_OFFSET) &= ~_BV(UART_HSE);
139         }
140         HW_REG(uart_base[uartno]+UARTFR_OFFSET) = 0;
141         HW_REG(uart_base[uartno]+UARTCTL_OFFSET) |= _BV(UART_RXE) | _BV(UART_TXE);
142         HW_REG(uart_base[uartno]+UARTCTL_OFFSET) |= _BV(UARTEN);
143
144         return UART_ERROR_OK;
145 }
146
147
148 void uart_putc(uint8_t uartno, uint8_t byte){
149         if(uartno>UART_MAX){
150                 return;
151         }
152         /* wait while the FIFO is full */
153         while(HW_REG(uart_base[uartno]+UARTFR_OFFSET)&_BV(UART_TXFF))
154                 ;
155         HW_REG(uart_base[uartno]+UARTDR_OFFSET) = (uint32_t)byte;
156 }
157
158 uint16_t uart_getc(uint8_t uartno){
159         if(uartno>UART_MAX){
160                 return 0xffff;
161         }
162         /* wait while the FIFO is empty */
163         while(HW_REG(uart_base[uartno]+UARTFR_OFFSET)&_BV(UART_RXFE))
164                 ;
165         return (uint16_t)HW_REG(uart_base[uartno]+UARTDR_OFFSET);
166 }
167
168 uint32_t uart_dataavail(uint8_t uartno){
169         if(uartno>UART_MAX){
170                 return 0;
171         }
172         /* wait while the FIFO is empty */
173         return(HW_REG(uart_base[uartno]+UARTFR_OFFSET)&_BV(UART_RXFE))?0:1;
174 }