/**************************************************************************************************
Filename: _hal_uart_usb.c
Revised: $Date: 2012-03-27 14:53:26 -0700 (Tue, 27 Mar 2012) $
Revision: $Revision: 29910 $
Description: This file contains the interface to the H/W UART driver by USB.
Copyright 2009-2012 Texas Instruments Incorporated. All rights reserved.
IMPORTANT: Your use of this Software is limited to those specific rights
granted under the terms of a software license agreement between the user
who downloaded the software, his/her employer (which must be your employer)
and Texas Instruments Incorporated (the "License"). You may not use this
Software unless you agree to abide by the terms of the License. The License
limits your use, and you acknowledge, that the Software may not be modified,
copied or distributed unless embedded on a Texas Instruments microcontroller
or used solely and exclusively in conjunction with a Texas Instruments radio
frequency transceiver, which is integrated into your product. Other than for
the foregoing purpose, you may not use, reproduce, copy, prepare derivative
works of, modify, distribute, perform, display or sell this Software and/or
its documentation for any purpose.
YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
PROVIDED �AS IS� WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
(INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
Should you have any questions regarding your right to use this Software,
contact Texas Instruments Incorporated at www.TI.com.
**************************************************************************************************/
/*********************************************************************
* INCLUDES
*/
#include "hal_uart.h"
#if defined MT_TASK
#include "MT_UART.h"
#endif
#include "usb_board_cfg.h"
#include "usb_cdc.h"
#include "usb_cdc_hooks.h"
#include "usb_firmware_library_config.h"
#include "usb_firmware_library_headers.h"
/*********************************************************************
* MACROS
*/
#if !defined HAL_UART_BAUD_RATE
#define HAL_UART_BAUD_RATE 115200
#endif
// The timeout tick is at 32-kHz, so multiply msecs by 33.
#define HAL_UART_MSECS_TO_TICKS 33
#if defined MT_TASK
#define HAL_UART_USB_HIGH MT_UART_DEFAULT_THRESHOLD
#define HAL_UART_USB_IDLE (MT_UART_DEFAULT_IDLE_TIMEOUT * HAL_UART_MSECS_TO_TICKS)
#define HAL_UART_USB_RX_MAX MT_UART_DEFAULT_MAX_RX_BUFF
#else
#if !defined HAL_UART_USB_HIGH
#define HAL_UART_USB_HIGH (HAL_UART_USB_RX_MAX / 2 - 16)
#endif
#if !defined HAL_UART_USB_IDLE
#define HAL_UART_USB_IDLE (6 * HAL_UART_MSECS_TO_TICKS)
#endif
#if !defined HAL_UART_USB_RX_MAX
#define HAL_UART_USB_RX_MAX 128
#endif
#endif
// Max USB packet size, per specification; see also usb_cdc_descriptor.s51
#if !defined HAL_UART_USB_TX_MAX
#define HAL_UART_USB_TX_MAX 64
#endif
/***********************************************************************************
* EXTERNAL VARIABLES
*/
/***********************************************************************************
* GLOBAL VARIABLES
*/
/***********************************************************************************
* LOCAL DATA
*/
static uint8 halUartRxH, halUartRxT, halUartRxQ[256];
static uint8 halUartTxH, halUartTxT, halUartTxQ[256];
#if !defined HAL_SB_BOOT_CODE
static uint8 rxTick;
static uint8 rxShdw;
static uint8 txMT;
static halUARTCBack_t uartCB;
#endif
/***********************************************************************************
* LOCAL FUNCTIONS
*/
static void HalUARTInitUSB(void);
static void HalUARTPollUSB(void);
static void halUartPollEvt(void);
static void halUartPollRx(void);
static void halUartPollTx(void);
/******************************************************************************
* FUNCTIONS
*/
/***********************************************************************************
* @fn usbUartInitUSB
*
* @brief USB UART init function.
* - Set initial line decoding to 8/NONE/1.
* - Initialise the USB Firmware Library and the USB controller.
*
* @param none
*
* @return none
*/
void HalUARTInitUSB(void)
{
// Set default line coding.
currentLineCoding.dteRate = HAL_UART_BAUD_RATE;
currentLineCoding.charFormat = CDC_CHAR_FORMAT_1_STOP_BIT;
currentLineCoding.parityType = CDC_PARITY_TYPE_NONE;
currentLineCoding.dataBits = 8;
// Init USB library
usbfwInit();
// Initialize the USB interrupt handler with bit mask containing all processed USBIRQ events
usbirqInit(0xFFFF);
#if defined HAL_SB_BOOT_CODE
HAL_USB_PULLUP_ENABLE(); // Enable pullup on D+.
#else
txMT = TRUE;
#endif
}
/******************************************************************************
* @fn HalUARTUnInitUSB
*
* @brief UnInitialize the USB.
*
* @param none
*
* @return none
*****************************************************************************/
static void HalUARTUnInitUSB(void)
{
P2IEN = 0;
IEN2 = 0;
HAL_USB_PULLUP_DISABLE();
HAL_USB_DISABLE;
}
#if !defined HAL_SB_BOOT_CODE
/******************************************************************************
* @fn HalUARTOpenUSB
*
* @brief Open a port according tp the configuration specified by parameter.
*
* @param config - contains configuration information
*
* @return none
*****************************************************************************/
static void HalUARTOpenUSB(halUARTCfg_t *config)
{
// Synchronize initial value to any value between 0 and 255
halUartRxH = halUartRxT;
uartCB = config->callBackFunc;
(void)config;
HAL_USB_PULLUP_ENABLE(); // Enable pullup on D+.
}
#endif
/***********************************************************************************
* @fn HalUartPollUSB
*
* @brief The USB UART main task function. Should be called from the OSAL main loop.
*
* @param none
*
* @return none
*/
void HalUARTPollUSB(void)
{
#if defined HAL_SB_BOOT_CODE
while (USBIF) usbirqHandler();
#endif
halUartPollEvt();
halUartPollRx();
halUartPollTx();
}
uint8 HalUARTRx(uint8 *buf, uint8 max);
uint8 HalUARTRx(uint8 *buf, uint8 max)
{
uint8 cnt = 0;
while ((halUartRxH != halUartRxT) && (cnt < max))
{
*buf++ = halUartRxQ[halUartRxH++];
cnt++;
}
return cnt;
}
void HalUARTTx(uint8 *buf, uint8 cnt);
void HalUARTTx(uint8 *buf, uint8 cnt)
{
while (cnt--)
{
halUartTxQ[halUartTxT++] = *buf++;
}
#if !defined HAL_SB_BOOT_CODE
txMT = FALSE;
#endif
}
/**************************************************************************************************
* @fn HalUARTRxAvailUSB()
*
* @brief Calculate Rx Buffer length - the number of bytes in the buffer.
*
* @param none
*
* @return length of current Rx Buffer
**************************************************************************************************/
static uint16 HalUARTRxAvailUSB(void)
{
return ((halUartRxT >= halUartRxH)?
halUartRxT - halUartRxH : sizeof(halUartRxQ) - halUartRxH + halUartRxT);
}
/***********************************************************************************
* @fn halUartPollEvt
*
* @brief Poll for USB events which are not directly related to the UART.
*
* @param none
*
* @return none
*/
static void halUartPollEvt(void)
{
// Handle reset signaling on the bus
if (USBIRQ_GET_EVENT_MASK() & USBIRQ_EVENT_RESET)
{
USBIRQ_CLEAR_EVENTS(USBIRQ_EVENT_RESET);
usbfwResetHandler();
}
// Handle packets on EP0
if (USBIRQ_GET_EVENT_MASK() & USBIRQ_EVENT_SETUP)
{
USBIRQ_CLEAR_EVENTS(USBIRQ_EVENT_SETUP);
usbfwSetupHandler();
}
// Handle USB suspend
if (USBIRQ_GET_EVENT_MASK() & USBIRQ_EVENT_SUSPEND)
{
// Clear USB suspend interrupt
USBIRQ_CLEAR_EVENTS(USBIRQ_EVENT_SUSPEND);
#if HAL_UART_USB_SUSPEND
// Take the chip into PM1 until a USB resume is deteceted.
usbsuspEnter();
#endif
// Running again; first clear RESUME interrupt
USBIRQ_CLEAR_EVENTS(USBIRQ_EVENT_RESUME);
}
}
/***********************************************************************************
* @fn halUartPollRx
*
* @brief Poll for data from USB.
*
* @param none
*
* @return none
*/
static void halUartPollRx(void)
{
uint8 cnt;
uint8 ep = USBFW_GET_SELECTED_ENDPOINT();
USBFW_SELECT_ENDPOINT(4);
// If the OUT endpoint has received a complete packet.
if (USBFW_OUT_ENDPOINT_DISARMED())
{
halIntState_t intState;
HAL_ENTER_CRITICAL_SECTION(intState);
// Get length of USB packet, this operation must not be interrupted.
cnt = USBFW_GET_OUT_ENDPOINT_COUNT_LOW();
cnt += USBFW_GET_OUT_ENDPOINT_COUNT_HIGH() >> 8;
HAL_EXIT_CRITICAL_SECTION(intState);
while (cnt--)
{
halUartRxQ[halUartRxT++] = USBF4;
}
USBFW_ARM_OUT_ENDPOINT();
#if !defined HAL_SB_BOOT_CODE
// If the USB has transferred in more Rx bytes, reset the Rx idle timer.
// Re-sync the shadow on any 1st byte(s) received.
if (rxTick == 0)
{
rxShdw = ST0;
}
rxTick = HAL_UART_USB_IDLE;
#endif
}
#if !defined HAL_SB_BOOT_CODE
else if (rxTick)
{
// Use the LSB of the sleep timer (ST0 must be read first anyway).
uint8 decr = ST0 - rxShdw;
if (rxTick > decr)
{
rxTick -= decr;
rxShdw = ST0;
}
else
{
rxTick = 0;
}
}
{
uint8 evt = 0;
cnt = halUartRxT - halUartRxH;
if (cnt >= HAL_UART_USB_HIGH)
{
evt = HAL_UART_RX_ABOUT_FULL;
}
else if (cnt && !rxTick)
{
evt = HAL_UART_RX_TIMEOUT;
}
if (evt && (NULL != uartCB))
{
uartCB(0, evt);
}
}
#endif
USBFW_SELECT_ENDPOINT(ep);
}
/***********************************************************************************
* @fn halUartPollTx
*
* @brief Poll for data to USB.
*
* @param none
*
* @return none
*/
static void halUartPollTx(void)
{
uint8 ep = USBFW_GET_SELECTED_ENDPOINT();
USBFW_SELECT_ENDPOINT(4);
// If the IN endpoint is ready to accept data.
if (USBFW_IN_ENDPOINT_DISARMED())
{
if (halUartTxT == halUartTxH)
{
#if !defined HAL_SB_BOOT_CODE
if (!txMT)
{
txMT = TRUE;
uartCB(0, HAL_UART_TX_EMPTY);
}
#endif
}
else
{
uint8 max = HAL_UART_USB_TX_MAX;
do
{
USBF4 = halUartTxQ[halUartTxH++];
} while ((halUartTxH != halUartTxT) && (0 != --max));
USBFW_ARM_IN_ENDPOINT();
}
}
USBFW_SELECT_ENDPOINT(ep);
}
/******************************************************************************
******************************************************************************/