669 lines
17 KiB
C
669 lines
17 KiB
C
/*
|
|
ChibiOS - Copyright (C) 2016 Andrew Wygle aka awygle
|
|
|
|
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.
|
|
*/
|
|
|
|
/**
|
|
* @file MSP430X/hal_serial_lld.c
|
|
* @brief MSP430X serial subsystem low level driver source.
|
|
*
|
|
* @addtogroup SERIAL
|
|
* @{
|
|
*/
|
|
|
|
#include "hal.h"
|
|
|
|
#if (HAL_USE_SERIAL == TRUE) || defined(__DOXYGEN__)
|
|
|
|
/*===========================================================================*/
|
|
/* Driver local definitions. */
|
|
/*===========================================================================*/
|
|
|
|
/*===========================================================================*/
|
|
/* Driver exported variables. */
|
|
/*===========================================================================*/
|
|
|
|
/** @brief USART0 serial driver identifier.*/
|
|
#if (MSP430X_SERIAL_USE_USART0 == TRUE) || defined(__DOXYGEN__)
|
|
#ifndef __MSP430_HAS_EUSCI_A0__
|
|
#error "Cannot find USCI module to use for SD0"
|
|
#endif
|
|
#ifdef MSP430X_USCI_A0_USED
|
|
#error "USCI module A0 already in use - USART0 not available"
|
|
#endif
|
|
SerialDriver SD0;
|
|
#define MSP430X_USCI_A0_USED
|
|
#endif
|
|
|
|
/** @brief USART1 serial driver identifier.*/
|
|
#if (MSP430X_SERIAL_USE_USART1 == TRUE) || defined(__DOXYGEN__)
|
|
#ifndef __MSP430_HAS_EUSCI_A1__
|
|
#error "Cannot find USCI module to use for SD1"
|
|
#endif
|
|
#ifdef MSP430X_USCI_A1_USED
|
|
#error "USCI module A1 already in use - USART1 not available"
|
|
#endif
|
|
SerialDriver SD1;
|
|
#define MSP430X_USCI_A1_USED
|
|
#endif
|
|
|
|
/** @brief USART2 serial driver identifier.*/
|
|
#if (MSP430X_SERIAL_USE_USART2 == TRUE) || defined(__DOXYGEN__)
|
|
#ifndef __MSP430_HAS_EUSCI_A2__
|
|
#error "Cannot find USCI module to use for SD2"
|
|
#endif
|
|
#ifdef MSP430X_USCI_A2_USED
|
|
#error "USCI module A2 already in use - USART2 not available"
|
|
#endif
|
|
SerialDriver SD2;
|
|
#define MSP430X_USCI_A2_USED
|
|
#endif
|
|
|
|
/** @brief USART3 serial driver identifier.*/
|
|
#if (MSP430X_SERIAL_USE_USART3 == TRUE) || defined(__DOXYGEN__)
|
|
#ifndef __MSP430_HAS_EUSCI_A3__
|
|
#error "Cannot find USCI module to use for SD3"
|
|
#endif
|
|
#ifdef MSP430X_USCI_A3_USED
|
|
#error "USCI module A3 already in use - USART3 not available"
|
|
#endif
|
|
SerialDriver SD3;
|
|
#define MSP430X_USCI_A3_USED
|
|
#endif
|
|
|
|
/*===========================================================================*/
|
|
/* Driver local variables and types. */
|
|
/*===========================================================================*/
|
|
|
|
/**
|
|
* @brief Driver default configuration.
|
|
*/
|
|
static const SerialConfig default_config = { SERIAL_DEFAULT_BITRATE };
|
|
|
|
/*===========================================================================*/
|
|
/* Driver local functions. */
|
|
/*===========================================================================*/
|
|
|
|
/**
|
|
* @brief UCBRS calculation.
|
|
* @details This function calculates the UCBRS value for oversampled baud
|
|
* rates.
|
|
*
|
|
* @param[in] frac Fractional part of baud rate division, times 10000.
|
|
*/
|
|
static uint8_t UCBRS(uint16_t frac) {
|
|
/* TODO there must be a better way */
|
|
if (frac < 529)
|
|
return 0x00;
|
|
else if (frac < 715)
|
|
return 0x01;
|
|
else if (frac < 835)
|
|
return 0x02;
|
|
else if (frac < 1001)
|
|
return 0x04;
|
|
else if (frac < 1252)
|
|
return 0x08;
|
|
else if (frac < 1430)
|
|
return 0x10;
|
|
else if (frac < 1670)
|
|
return 0x20;
|
|
else if (frac < 2147)
|
|
return 0x11;
|
|
else if (frac < 2224)
|
|
return 0x21;
|
|
else if (frac < 2503)
|
|
return 0x22;
|
|
else if (frac < 3000)
|
|
return 0x44;
|
|
else if (frac < 3335)
|
|
return 0x25;
|
|
else if (frac < 3575)
|
|
return 0x49;
|
|
else if (frac < 3753)
|
|
return 0x4A;
|
|
else if (frac < 4003)
|
|
return 0x52;
|
|
else if (frac < 4286)
|
|
return 0x92;
|
|
else if (frac < 4378)
|
|
return 0x53;
|
|
else if (frac < 5002)
|
|
return 0x55;
|
|
else if (frac < 5715)
|
|
return 0xAA;
|
|
else if (frac < 6003)
|
|
return 0x6B;
|
|
else if (frac < 6254)
|
|
return 0xAD;
|
|
else if (frac < 6432)
|
|
return 0xB5;
|
|
else if (frac < 6667)
|
|
return 0xB6;
|
|
else if (frac < 7001)
|
|
return 0xD6;
|
|
else if (frac < 7147)
|
|
return 0xB7;
|
|
else if (frac < 7503)
|
|
return 0xBB;
|
|
else if (frac < 7861)
|
|
return 0xDD;
|
|
else if (frac < 8004)
|
|
return 0xED;
|
|
else if (frac < 8333)
|
|
return 0xEE;
|
|
else if (frac < 8464)
|
|
return 0xBF;
|
|
else if (frac < 8572)
|
|
return 0xDF;
|
|
else if (frac < 8751)
|
|
return 0xEF;
|
|
else if (frac < 9004)
|
|
return 0xF7;
|
|
else if (frac < 9170)
|
|
return 0xFB;
|
|
else if (frac < 9288)
|
|
return 0xFD;
|
|
else
|
|
return 0xFE;
|
|
}
|
|
|
|
/**
|
|
* @brief Modulation control word calculator.
|
|
* @details This function calculates the modulation control word from the
|
|
* input clock frequency and the requested baud rate.
|
|
*
|
|
* @param[in] baud Requested baud rate
|
|
* @param[in] freq Frequency of the clock driving the USCI module
|
|
*/
|
|
static uint16_t UCAxMCTLW(uint32_t baud, uint32_t freq) {
|
|
|
|
uint16_t n = freq / baud;
|
|
/*uint16_t frac = (freq * 10000 / baud) - ((freq / baud) * 10000);*/
|
|
uint16_t frac = (freq - (n * baud)) * 10000 / baud;
|
|
if (n > 16) {
|
|
while (n > 16) {
|
|
n -= 16;
|
|
}
|
|
return (UCBRS(frac) << 8) | (n << 4) | UCOS16;
|
|
}
|
|
return UCBRS(frac) << 8;
|
|
}
|
|
|
|
/**
|
|
* @brief UCBRW calculation.
|
|
* @details This function calculates the UCBRW value for all baud
|
|
* rates.
|
|
*
|
|
* @param[in] baud Requested baud rate
|
|
* @param[in] freq Frequency of the clock driving the USCI module
|
|
*/
|
|
static uint16_t UCAxBRW(uint32_t baud, uint32_t freq) {
|
|
uint16_t n = freq / baud;
|
|
if (n > 16) {
|
|
return n >> 4;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
#if (MSP430X_SERIAL_USE_USART0 == TRUE) || defined(__DOXYGEN__)
|
|
static void usart0_init(const SerialConfig * config) {
|
|
UCA0BRW = UCAxBRW(config->sc_bitrate, MSP430X_USART0_CLK_FREQ);
|
|
UCA0MCTLW = UCAxMCTLW(config->sc_bitrate, MSP430X_USART0_CLK_FREQ);
|
|
UCA0STATW = 0;
|
|
UCA0ABCTL = 0;
|
|
UCA0IRCTL = 0;
|
|
UCA0CTLW0 = (MSP430X_USART0_PARITY << 14) | (MSP430X_USART0_ORDER << 13) |
|
|
(MSP430X_USART0_SIZE << 12) | (MSP430X_USART0_STOP << 11) |
|
|
(MSP430X_USART0_UCSSEL);
|
|
UCA0IE = UCRXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART1 == TRUE) || defined(__DOXYGEN__)
|
|
static void usart1_init(const SerialConfig * config) {
|
|
UCA1BRW = UCAxBRW(config->sc_bitrate, MSP430X_USART1_CLK_FREQ);
|
|
UCA1MCTLW = UCAxMCTLW(config->sc_bitrate, MSP430X_USART1_CLK_FREQ);
|
|
UCA1STATW = 0;
|
|
UCA1ABCTL = 0;
|
|
UCA1IRCTL = 0;
|
|
UCA1CTLW0 = (MSP430X_USART1_PARITY << 14) | (MSP430X_USART1_ORDER << 13) |
|
|
(MSP430X_USART1_SIZE << 12) | (MSP430X_USART1_STOP << 11) |
|
|
(MSP430X_USART1_UCSSEL);
|
|
UCA1IE = UCRXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART2 == TRUE) || defined(__DOXYGEN__)
|
|
static void usart2_init(const SerialConfig * config) {
|
|
UCA2BRW = UCAxBRW(config->sc_bitrate, MSP430X_USART2_CLK_FREQ);
|
|
UCA2MCTLW = UCAxMCTLW(config->sc_bitrate);
|
|
UCA2STATW = 0;
|
|
UCA2ABCTL = 0;
|
|
UCA2IRCTL = 0;
|
|
UCA2CTLW0 = (MSP430X_USART2_PARITY << 14) | (MSP430X_USART2_ORDER << 13) |
|
|
(MSP430X_USART2_SIZE << 12) | (MSP430X_USART2_STOP << 11) |
|
|
(MSP430X_USART2_UCSSEL);
|
|
UCA2IE = UCRXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART3 == TRUE) || defined(__DOXYGEN__)
|
|
static void usart3_init(const SerialConfig * config) {
|
|
UCA3BRW = UCAxBRW(config->sc_bitrate, MSP430X_USART3_CLK_FREQ);
|
|
UCA3MCTLW = UCAxMCTLW(config->sc_bitrate, MSP430X_USART3_CLK_FREQ);
|
|
UCA3STATW = 0;
|
|
UCA3ABCTL = 0;
|
|
UCA3IRCTL = 0;
|
|
UCA3CTLW0 = (MSP430X_USART3_PARITY << 14) | (MSP430X_USART3_ORDER << 13) |
|
|
(MSP430X_USART3_SIZE << 12) | (MSP430X_USART3_STOP << 11) |
|
|
(MSP430X_USART3_UCSSEL);
|
|
UCA3IE = UCRXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART0 == TRUE) || defined(__DOXYGEN__)
|
|
static void notify0(io_queue_t * qp) {
|
|
|
|
(void)qp;
|
|
UCA0IE |= UCTXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART1 == TRUE) || defined(__DOXYGEN__)
|
|
static void notify1(io_queue_t * qp) {
|
|
|
|
(void)qp;
|
|
UCA1IE |= UCTXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART2 == TRUE) || defined(__DOXYGEN__)
|
|
static void notify2(io_queue_t * qp) {
|
|
|
|
(void)qp;
|
|
UCA2IE |= UCTXIE;
|
|
}
|
|
#endif
|
|
|
|
#if (MSP430X_SERIAL_USE_USART3 == TRUE) || defined(__DOXYGEN__)
|
|
static void notify3(io_queue_t * qp) {
|
|
|
|
(void)qp;
|
|
UCA3IE |= UCTXIE;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Error handling routine.
|
|
*
|
|
* @param[in] sra USCI status register containing errors
|
|
* @param[in] sdp pointer to a @p SerialDriver object
|
|
*/
|
|
static void set_error(uint16_t sra, SerialDriver * sdp) {
|
|
eventflags_t sts = 0;
|
|
|
|
if (sra & UCOE)
|
|
sts |= SD_OVERRUN_ERROR;
|
|
if (sra & UCPE)
|
|
sts |= SD_PARITY_ERROR;
|
|
if (sra & UCFE)
|
|
sts |= SD_FRAMING_ERROR;
|
|
osalSysLockFromISR();
|
|
chnAddFlagsI(sdp, sts);
|
|
osalSysUnlockFromISR();
|
|
}
|
|
|
|
/*===========================================================================*/
|
|
/* Driver interrupt handlers. */
|
|
/*===========================================================================*/
|
|
|
|
#if MSP430X_SERIAL_USE_USART0 || defined(__DOXYGEN__)
|
|
/**
|
|
* @brief USART0 interrupt handler.
|
|
*
|
|
* @isr
|
|
*/
|
|
PORT_IRQ_HANDLER(USCI_A0_VECTOR) {
|
|
msg_t b;
|
|
|
|
OSAL_IRQ_PROLOGUE();
|
|
|
|
switch (__even_in_range(UCA0IV, USCI_UART_UCTXCPTIFG)) {
|
|
case USCI_UART_UCRXIFG: /* RX interrupt */
|
|
|
|
/* Detect errors */
|
|
if (UCA0STATW & UCRXERR)
|
|
set_error(UCA0STATW, &SD0);
|
|
|
|
/* Data available */
|
|
osalSysLockFromISR();
|
|
sdIncomingDataI(&SD0, UCA0RXBUF);
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXIFG: /* TX interrupt */
|
|
|
|
/* Transmission buffer empty */
|
|
osalSysLockFromISR();
|
|
b = sdRequestDataI(&SD0);
|
|
if (b < Q_OK) {
|
|
chnAddFlagsI(&SD0, CHN_OUTPUT_EMPTY);
|
|
UCA0IE = (UCA0IE & ~UCTXIE) | UCTXCPTIE;
|
|
UCA0IFG |= UCTXIFG; /* If we don't write to TXBUF, IFG won't get set */
|
|
}
|
|
else
|
|
UCA0TXBUF = b;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXCPTIFG: /* TX complete interrupt */
|
|
|
|
/* Physical transmission end */
|
|
osalSysLockFromISR();
|
|
if (oqIsEmptyI(&SD0.oqueue))
|
|
chnAddFlagsI(&SD0, CHN_TRANSMISSION_END);
|
|
UCA0IE &= ~UCTXCPTIE;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
default: /* other interrupts */
|
|
osalDbgAssert(false, "unhandled serial interrupt");
|
|
break;
|
|
}
|
|
|
|
OSAL_IRQ_EPILOGUE();
|
|
}
|
|
#endif
|
|
|
|
#if MSP430X_SERIAL_USE_USART1 || defined(__DOXYGEN__)
|
|
/**
|
|
* @brief USART1 interrupt handler.
|
|
*
|
|
* @isr
|
|
*/
|
|
PORT_IRQ_HANDLER(USCI_A1_VECTOR) {
|
|
msg_t b;
|
|
|
|
OSAL_IRQ_PROLOGUE();
|
|
|
|
switch (__even_in_range(UCA1IV, USCI_UART_UCTXCPTIFG)) {
|
|
case USCI_UART_UCRXIFG: /* RX interrupt */
|
|
|
|
/* Detect errors */
|
|
if (UCA1STATW & UCRXERR)
|
|
set_error(UCA1STATW, &SD1);
|
|
|
|
/* Data available */
|
|
osalSysLockFromISR();
|
|
sdIncomingDataI(&SD1, UCA1RXBUF);
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXIFG: /* TX interrupt */
|
|
|
|
/* Transmission buffer empty */
|
|
osalSysLockFromISR();
|
|
b = sdRequestDataI(&SD1);
|
|
if (b < Q_OK) {
|
|
chnAddFlagsI(&SD1, CHN_OUTPUT_EMPTY);
|
|
UCA1IE = (UCA1IE & ~UCTXIE) | UCTXCPTIE;
|
|
UCA1IFG |= UCTXIFG; /* If we don't write to TXBUF, IFG won't get set */
|
|
}
|
|
else
|
|
UCA1TXBUF = b;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXCPTIFG: /* TX complete interrupt */
|
|
|
|
/* Physical transmission end */
|
|
osalSysLockFromISR();
|
|
if (oqIsEmptyI(&SD1.oqueue))
|
|
chnAddFlagsI(&SD1, CHN_TRANSMISSION_END);
|
|
UCA1IE &= ~UCTXCPTIE;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
default: /* other interrupts */
|
|
osalDbgAssert(false, "unhandled serial interrupt");
|
|
break;
|
|
}
|
|
|
|
OSAL_IRQ_EPILOGUE();
|
|
}
|
|
#endif
|
|
|
|
#if MSP430X_SERIAL_USE_USART2 || defined(__DOXYGEN__)
|
|
/**
|
|
* @brief USART2 interrupt handler.
|
|
*
|
|
* @isr
|
|
*/
|
|
PORT_IRQ_HANDLER(USCI_A2_VECTOR) {
|
|
msg_t b;
|
|
|
|
OSAL_IRQ_PROLOGUE();
|
|
|
|
switch (__even_in_range(UCA2IV, USCI_UART_UCTXCPTIFG)) {
|
|
case USCI_UART_UCRXIFG: /* RX interrupt */
|
|
|
|
/* Detect errors */
|
|
if (UCA2STATW & UCRXERR)
|
|
set_error(UCA2STATW, &SD2);
|
|
|
|
/* Data available */
|
|
osalSysLockFromISR();
|
|
sdIncomingDataI(&SD2, UCA2RXBUF);
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXIFG: /* TX interrupt */
|
|
|
|
/* Transmission buffer empty */
|
|
osalSysLockFromISR();
|
|
b = sdRequestDataI(&SD2);
|
|
if (b < Q_OK) {
|
|
chnAddFlagsI(&SD2, CHN_OUTPUT_EMPTY);
|
|
UCA2IE = (UCA2IE & ~UCTXIE) | UCTXCPTIE;
|
|
UCA2IFG |= UCTXIFG; /* If we don't write to TXBUF, IFG won't get set */
|
|
}
|
|
else
|
|
UCA2TXBUF = b;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXCPTIFG: /* TX complete interrupt */
|
|
|
|
/* Physical transmission end */
|
|
osalSysLockFromISR();
|
|
if (oqIsEmptyI(&SD2.oqueue))
|
|
chnAddFlagsI(&SD2, CHN_TRANSMISSION_END);
|
|
UCA2IE &= ~UCTXCPTIE;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
default: /* other interrupts */
|
|
osalDbgAssert(false, "unhandled serial interrupt");
|
|
break;
|
|
}
|
|
|
|
OSAL_IRQ_EPILOGUE();
|
|
}
|
|
#endif
|
|
|
|
#if MSP430X_SERIAL_USE_USART3 || defined(__DOXYGEN__)
|
|
/**
|
|
* @brief USART3 interrupt handler.
|
|
*
|
|
* @isr
|
|
*/
|
|
PORT_IRQ_HANDLER(USCI_A3_VECTOR) {
|
|
msg_t b;
|
|
|
|
OSAL_IRQ_PROLOGUE();
|
|
|
|
switch (__even_in_range(UCA3IV, USCI_UART_UCTXCPTIFG)) {
|
|
case USCI_UART_UCRXIFG: /* RX interrupt */
|
|
|
|
/* Detect errors */
|
|
if (UCA3STATW & UCRXERR)
|
|
set_error(UCA3STATW, &SD3);
|
|
|
|
/* Data available */
|
|
osalSysLockFromISR();
|
|
sdIncomingDataI(&SD3, UCA3RXBUF);
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXIFG: /* TX interrupt */
|
|
|
|
/* Transmission buffer empty */
|
|
osalSysLockFromISR();
|
|
b = sdRequestDataI(&SD3);
|
|
if (b < Q_OK) {
|
|
chnAddFlagsI(&SD3, CHN_OUTPUT_EMPTY);
|
|
UCA3IE = (UCA3IE & ~UCTXIE) | UCTXCPTIE;
|
|
UCA3IFG |= UCTXIFG; /* If we don't write to TXBUF, IFG won't get set */
|
|
}
|
|
else
|
|
UCA3TXBUF = b;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
case USCI_UART_UCTXCPTIFG: /* TX complete interrupt */
|
|
|
|
/* Physical transmission end */
|
|
osalSysLockFromISR();
|
|
if (oqIsEmptyI(&SD3.oqueue))
|
|
chnAddFlagsI(&SD3, CHN_TRANSMISSION_END);
|
|
UCA3IE &= ~UCTXCPTIE;
|
|
osalSysUnlockFromISR();
|
|
break;
|
|
|
|
default: /* other interrupts */
|
|
osalDbgAssert(false, "unhandled serial interrupt");
|
|
break;
|
|
}
|
|
|
|
OSAL_IRQ_EPILOGUE();
|
|
}
|
|
#endif
|
|
|
|
/*===========================================================================*/
|
|
/* Driver exported functions. */
|
|
/*===========================================================================*/
|
|
|
|
/**
|
|
* @brief Low level serial driver initialization.
|
|
*
|
|
* @notapi
|
|
*/
|
|
void sd_lld_init(void) {
|
|
|
|
#if MSP430X_SERIAL_USE_USART0 == TRUE
|
|
sdObjectInit(&SD0, NULL, notify0);
|
|
#endif
|
|
|
|
#if MSP430X_SERIAL_USE_USART1 == TRUE
|
|
sdObjectInit(&SD1, NULL, notify1);
|
|
#endif
|
|
|
|
#if MSP430X_SERIAL_USE_USART2 == TRUE
|
|
sdObjectInit(&SD2, NULL, notify2);
|
|
#endif
|
|
|
|
#if MSP430X_SERIAL_USE_USART3 == TRUE
|
|
sdObjectInit(&SD3, NULL, notify3);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @brief Low level serial driver configuration and (re)start.
|
|
*
|
|
* @param[in] sdp pointer to a @p SerialDriver object
|
|
* @param[in] config the architecture-dependent serial driver configuration.
|
|
* If this parameter is set to @p NULL then a default
|
|
* configuration is used.
|
|
*
|
|
* @notapi
|
|
*/
|
|
void sd_lld_start(SerialDriver * sdp, const SerialConfig * config) {
|
|
|
|
if (config == NULL) {
|
|
config = &default_config;
|
|
}
|
|
|
|
if (sdp->state == SD_STOP) {
|
|
#if MSP430X_SERIAL_USE_USART0 == TRUE
|
|
if (&SD0 == sdp) {
|
|
usart0_init(config);
|
|
}
|
|
#endif
|
|
#if MSP430X_SERIAL_USE_USART1 == TRUE
|
|
if (&SD1 == sdp) {
|
|
usart1_init(config);
|
|
}
|
|
#endif
|
|
#if MSP430X_SERIAL_USE_USART2 == TRUE
|
|
if (&SD2 == sdp) {
|
|
usart2_init(config);
|
|
}
|
|
#endif
|
|
#if MSP430X_SERIAL_USE_USART3 == TRUE
|
|
if (&SD3 == sdp) {
|
|
usart3_init(config);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Low level serial driver stop.
|
|
* @details De-initializes the USART, stops the associated clock, resets the
|
|
* interrupt vector.
|
|
*
|
|
* @param[in] sdp pointer to a @p SerialDriver object
|
|
*
|
|
* @notapi
|
|
*/
|
|
void sd_lld_stop(SerialDriver * sdp) {
|
|
|
|
if (sdp->state == SD_READY) {
|
|
#if MSP430X_SERIAL_USE_USART0 == TRUE
|
|
if (&SD0 == sdp) {
|
|
UCA0CTLW0 = UCSWRST;
|
|
}
|
|
#endif
|
|
#if MSP430X_SERIAL_USE_USART1 == TRUE
|
|
if (&SD1 == sdp) {
|
|
UCA1CTLW0 = UCSWRST;
|
|
}
|
|
#endif
|
|
#if MSP430X_SERIAL_USE_USART2 == TRUE
|
|
if (&SD2 == sdp) {
|
|
UCA2CTLW0 = UCSWRST;
|
|
}
|
|
#endif
|
|
#if MSP430X_SERIAL_USE_USART3 == TRUE
|
|
if (&SD3 == sdp) {
|
|
UCA3CTLW0 = UCSWRST;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#endif /* HAL_USE_SERIAL == TRUE */
|
|
|
|
/** @} */
|