| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 <assert.h> |
| #include <stdlib.h> |
| #include "os/mynewt.h" |
| #include "hal/hal_uart.h" |
| #include "bsp/bsp.h" |
| #include "mcu/mips_hal.h" |
| #include "mcu/pps.h" |
| |
| #include <xc.h> |
| |
| #define UxMODE(U) (base_address[U][0x0 / 0x4]) |
| #define UxMODESET(U) (base_address[U][0x8 / 0x4]) |
| #define UxSTA(U) (base_address[U][0x10 / 0x4]) |
| #define UxTXREG(U) (base_address[U][0x20 / 0x4]) |
| #define UxRXREG(U) (base_address[U][0x30 / 0x4]) |
| #define UxBRG(U) (base_address[U][0x40 / 0x4]) |
| |
| static volatile uint32_t* base_address[UART_CNT] = { |
| (volatile uint32_t *)_UART1_BASE_ADDRESS, |
| (volatile uint32_t *)_UART2_BASE_ADDRESS, |
| (volatile uint32_t *)_UART3_BASE_ADDRESS, |
| (volatile uint32_t *)_UART4_BASE_ADDRESS, |
| }; |
| |
| struct hal_uart { |
| volatile uint8_t u_rx_stall:1; |
| volatile uint8_t u_rx_data; |
| hal_uart_rx_char u_rx_func; |
| hal_uart_tx_char u_tx_func; |
| hal_uart_tx_done u_tx_done; |
| void *u_func_arg; |
| const struct mips_uart_cfg *u_pins; |
| }; |
| static struct hal_uart uarts[UART_CNT]; |
| |
| int |
| hal_uart_init_cbs(int port, hal_uart_tx_char tx_func, hal_uart_tx_done tx_done, |
| hal_uart_rx_char rx_func, void *arg) |
| { |
| uarts[port].u_rx_func = rx_func; |
| uarts[port].u_tx_func = tx_func; |
| uarts[port].u_tx_done = tx_done; |
| uarts[port].u_func_arg = arg; |
| return 0; |
| } |
| |
| static void |
| uart_disable_tx_int(int port) |
| { |
| switch (port) { |
| case 0: |
| IEC1CLR = _IEC1_U1TXIE_MASK; |
| break; |
| case 1: |
| IEC1CLR = _IEC1_U2TXIE_MASK; |
| break; |
| case 2: |
| IEC2CLR = _IEC2_U3TXIE_MASK; |
| break; |
| case 3: |
| IEC2CLR = _IEC2_U4TXIE_MASK; |
| break; |
| } |
| } |
| |
| static void |
| uart_enable_tx_int(int port) |
| { |
| switch (port) { |
| case 0: |
| IEC1SET = _IEC1_U1TXIE_MASK; |
| break; |
| case 1: |
| IEC1SET = _IEC1_U2TXIE_MASK; |
| break; |
| case 2: |
| IEC2SET = _IEC2_U3TXIE_MASK; |
| break; |
| case 3: |
| IEC2SET = _IEC2_U4TXIE_MASK; |
| break; |
| } |
| } |
| |
| static void |
| uart_disable_rx_int(int port) |
| { |
| switch (port) { |
| case 0: |
| IEC1CLR = _IEC1_U1RXIE_MASK; |
| break; |
| case 1: |
| IEC1CLR = _IEC1_U2RXIE_MASK; |
| break; |
| case 2: |
| IEC1CLR = _IEC1_U3RXIE_MASK; |
| break; |
| case 3: |
| IEC2CLR = _IEC2_U4RXIE_MASK; |
| break; |
| } |
| } |
| |
| static void |
| uart_enable_rx_int(int port) |
| { |
| switch (port) { |
| case 0: |
| IEC1SET = _IEC1_U1RXIE_MASK; |
| break; |
| case 1: |
| IEC1SET = _IEC1_U2RXIE_MASK; |
| break; |
| case 2: |
| IEC1SET = _IEC1_U3RXIE_MASK; |
| break; |
| case 3: |
| IEC2SET = _IEC2_U4RXIE_MASK; |
| break; |
| } |
| } |
| |
| static void |
| uart_receive_ready(int port) |
| { |
| uarts[port].u_rx_data = UxRXREG(port); |
| |
| int c = uarts[port].u_rx_func(uarts[port].u_func_arg, |
| uarts[port].u_rx_data); |
| if (c < 0) { |
| uart_disable_rx_int(port); |
| uarts[port].u_rx_stall = 1; |
| } |
| } |
| |
| static void |
| uart_transmit_ready(int port) |
| { |
| while(!(UxSTA(port) & _U1STA_UTXBF_MASK)) { |
| int c = uarts[port].u_tx_func(uarts[port].u_func_arg); |
| if (c < 0) { |
| uart_disable_tx_int(port); |
| /* call tx done cb */ |
| if (uarts[port].u_tx_done) { |
| uarts[port].u_tx_done(uarts[port].u_func_arg); |
| } |
| break; |
| } |
| UxTXREG(port) = (uint32_t)c & 0xff; |
| } |
| } |
| |
| void |
| __attribute__((interrupt(IPL1AUTO), vector(_UART_1_VECTOR))) uart_1_isr(void) |
| { |
| uint32_t sta = U1STA; |
| if (sta & _U1STA_URXDA_MASK) { |
| uart_receive_ready(0); |
| IFS1CLR = _IFS1_U1RXIF_MASK; |
| } |
| if (sta & _U1STA_TRMT_MASK) { |
| uart_transmit_ready(0); |
| IFS1CLR = _IFS1_U1TXIF_MASK; |
| } |
| } |
| |
| void |
| __attribute__((interrupt(IPL1AUTO), vector(_UART_2_VECTOR))) uart_2_isr(void) |
| { |
| uint32_t sta = U2STA; |
| if (sta & _U2STA_URXDA_MASK) { |
| uart_receive_ready(1); |
| IFS1CLR = _IFS1_U2RXIF_MASK; |
| } |
| if (sta & _U2STA_TRMT_MASK) { |
| uart_transmit_ready(1); |
| IFS1CLR = _IFS1_U2TXIF_MASK; |
| } |
| } |
| |
| void |
| __attribute__((interrupt(IPL1AUTO), vector(_UART_3_VECTOR))) uart_3_isr(void) |
| { |
| uint32_t sta = U3STA; |
| if (sta & _U3STA_URXDA_MASK) { |
| uart_receive_ready(2); |
| IFS1CLR = _IFS1_U3RXIF_MASK; |
| } |
| if (sta & _U3STA_TRMT_MASK) { |
| uart_transmit_ready(2); |
| IFS2CLR = _IFS2_U3TXIF_MASK; |
| } |
| } |
| |
| void |
| __attribute__((interrupt(IPL1AUTO), vector(_UART_4_VECTOR))) uart_4_isr(void) |
| { |
| uint32_t sta = U4STA; |
| if (sta & _U4STA_URXDA_MASK) { |
| uart_receive_ready(3); |
| IFS2CLR = _IFS2_U4RXIF_MASK; |
| } |
| if (sta & _U4STA_TRMT_MASK) { |
| uart_transmit_ready(3); |
| IFS2CLR = _IFS2_U4TXIF_MASK; |
| } |
| } |
| |
| void |
| hal_uart_start_rx(int port) |
| { |
| if (uarts[port].u_rx_stall) { |
| /* recover saved data */ |
| uint32_t sr; |
| __HAL_DISABLE_INTERRUPTS(sr); |
| int c = uarts[port].u_rx_func(uarts[port].u_func_arg, |
| uarts[port].u_rx_data); |
| if (c >= 0) { |
| uarts[port].u_rx_stall = 0; |
| /* enable RX interrupt */ |
| uart_enable_rx_int(port); |
| } |
| __HAL_ENABLE_INTERRUPTS(sr); |
| } |
| } |
| |
| void |
| hal_uart_start_tx(int port) |
| { |
| uart_enable_tx_int(port); |
| } |
| |
| void |
| hal_uart_blocking_tx(int port, uint8_t data) |
| { |
| while (!(UxSTA(port) & _U1STA_TRMT_MASK)) { |
| } |
| |
| UxTXREG(port) = data; |
| } |
| |
| int |
| hal_uart_init(int port, void *arg) |
| { |
| if (port >= UART_CNT) { |
| return -1; |
| } |
| |
| uarts[port].u_pins = arg; |
| |
| return 0; |
| } |
| |
| int |
| hal_uart_config(int port, int32_t baudrate, uint8_t databits, uint8_t stopbits, |
| enum hal_uart_parity parity, enum hal_uart_flow_ctl flow_ctl) |
| { |
| uint32_t peripheral_clk = MYNEWT_VAL(CLOCK_FREQ) / 2; |
| |
| // check input |
| if ((databits < 8) || (databits > 9) || (stopbits < 1) || (stopbits > 2)) { |
| return -1; |
| } |
| |
| /* XXX: flow control currently unsupported */ |
| (void) flow_ctl; |
| uarts[port].u_rx_stall = 0; |
| |
| uint16_t mode = _U1MODE_BRGH_MASK | (stopbits >> 1); |
| switch (parity) { |
| case HAL_UART_PARITY_NONE: |
| if (databits == 9) { |
| mode |= _U1MODE_PDSEL_MASK; |
| } |
| break; |
| case HAL_UART_PARITY_ODD: |
| if (databits == 9) { // PIC does not do 9 bit data + parity. |
| return -1; |
| } |
| mode |= _U1MODE_PDSEL1_MASK; |
| break; |
| case HAL_UART_PARITY_EVEN: |
| if (databits == 9) { |
| return -1; |
| } |
| mode |= _U1MODE_PDSEL0_MASK; |
| break; |
| default: |
| return -1; |
| } |
| |
| /* Configure TX/RX pins */ |
| if (uarts[port].u_pins) { |
| int ret = 0; |
| switch(port) { |
| case 0: |
| ret += pps_configure_output(uarts[port].u_pins->tx, U1TX_OUT_FUNC); |
| ret += pps_configure_input(uarts[port].u_pins->rx, U1RX_IN_FUNC); |
| break; |
| case 1: |
| ret += pps_configure_output(uarts[port].u_pins->tx, U2TX_OUT_FUNC); |
| ret += pps_configure_input(uarts[port].u_pins->rx, U2RX_IN_FUNC); |
| break; |
| case 2: |
| ret += pps_configure_output(uarts[port].u_pins->tx, U3TX_OUT_FUNC); |
| ret += pps_configure_input(uarts[port].u_pins->rx, U3RX_IN_FUNC); |
| break; |
| case 3: |
| ret += pps_configure_output(uarts[port].u_pins->tx, U4TX_OUT_FUNC); |
| ret += pps_configure_input(uarts[port].u_pins->rx, U4RX_IN_FUNC); |
| break; |
| default: |
| return -1; |
| } |
| if (ret) { |
| return -1; |
| } |
| } |
| |
| uint16_t divisor = peripheral_clk / (4 * baudrate) - 1; |
| |
| UxMODE(port) = 0; |
| __asm__("nop"); |
| UxBRG(port) = divisor; |
| UxMODE(port) = mode; |
| UxSTA(port) = _U1STA_URXEN_MASK | _U1STA_UTXEN_MASK; |
| |
| switch (port) { |
| case 0: |
| /* clear RX interrupt flag */ |
| IFS1CLR = _IFS1_U1RXIF_MASK; |
| |
| /* enable RX interrupt */ |
| IEC1SET = _IEC1_U1RXIE_MASK; |
| |
| /* set interrupt priority */ |
| IPC7CLR = _IPC7_U1IP_MASK; |
| IPC7SET = (1 << _IPC7_U1IP_POSITION); // priority 1 |
| /* set interrupt subpriority */ |
| IPC7CLR = _IPC7_U1IS_MASK; |
| IPC7SET = (0 << _IPC7_U1IS_POSITION); // subpriority 0 |
| break; |
| case 1: |
| /* clear RX interrupt flag */ |
| IFS1CLR = _IFS1_U2RXIF_MASK; |
| |
| /* enable RX interrupt */ |
| IEC1SET = _IEC1_U2RXIE_MASK; |
| |
| /* set interrupt priority */ |
| IPC9CLR = _IPC9_U2IP_MASK; |
| IPC9SET = (1 << _IPC9_U2IP_POSITION); // priority 1 |
| /* set interrupt subpriority */ |
| IPC9CLR = _IPC9_U2IS_MASK; |
| IPC9SET = (0 << _IPC9_U2IS_POSITION); // subpriority 0 |
| break; |
| case 2: |
| /* clear RX interrupt flag */ |
| IFS1CLR = _IFS1_U3RXIF_MASK; |
| |
| /* enable RX interrupt */ |
| IEC1SET = _IEC1_U3RXIE_MASK; |
| |
| /* set interrupt priority */ |
| IPC9CLR = _IPC9_U3IP_MASK; |
| IPC9SET = (1 << _IPC9_U3IP_POSITION); // priority 1 |
| /* set interrupt subpriority */ |
| IPC9CLR = _IPC9_U3IS_MASK; |
| IPC9SET = (0 << _IPC9_U3IS_POSITION); // subpriority 0 |
| break; |
| case 3: |
| /* clear RX interrupt flag */ |
| IFS2CLR = _IFS2_U4RXIF_MASK; |
| |
| /* enable RX interrupt */ |
| IEC2SET = _IEC2_U4RXIE_MASK; |
| |
| /* set interrupt priority */ |
| IPC9CLR = _IPC9_U4IP_MASK; |
| IPC9SET = (1 << _IPC9_U4IP_POSITION); // priority 1 |
| /* set interrupt subpriority */ |
| IPC9CLR = _IPC9_U4IS_MASK; |
| IPC9SET = (0 << _IPC9_U4IS_POSITION); // subpriority 0 |
| break; |
| } |
| |
| UxMODESET(port) = _U1MODE_ON_MASK; |
| |
| return 0; |
| } |
| |
| int |
| hal_uart_close(int port) |
| { |
| if (port >= UART_CNT) { |
| return -1; |
| } |
| |
| UxMODE(port) = 0; |
| uart_disable_rx_int(port); |
| |
| return 0; |
| } |
