UART.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2016, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef ti_drivers_UART__include
#define ti_drivers_UART__include

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stddef.h>

#define UART_CMD_RESERVED            32

#define UART_STATUS_RESERVED        -32

#define UART_STATUS_SUCCESS         0

#define UART_STATUS_ERROR          -1

#define UART_STATUS_UNDEFINEDCMD   -2

#define UART_CMD_PEEK               0

#define UART_CMD_ISAVAILABLE        1

#define UART_CMD_GETRXCOUNT         2

#define UART_CMD_RXENABLE           3

#define UART_CMD_RXDISABLE          4

#define UART_ERROR  UART_STATUS_ERROR

#define UART_WAIT_FOREVER (~0)

typedef struct UART_Config      *UART_Handle;

typedef void        (*UART_Callback)    (UART_Handle, void *buf, size_t count);

typedef enum UART_Mode {
    UART_MODE_BLOCKING,

    UART_MODE_CALLBACK
} UART_Mode;

typedef enum UART_ReturnMode {
    UART_RETURN_FULL,

    UART_RETURN_NEWLINE
} UART_ReturnMode;

typedef enum UART_DataMode {
    UART_DATA_BINARY = 0, 
    UART_DATA_TEXT = 1    
} UART_DataMode;

typedef enum UART_Echo {
    UART_ECHO_OFF = 0,  
    UART_ECHO_ON = 1    
} UART_Echo;

typedef enum UART_LEN {
    UART_LEN_5 = 0,        
    UART_LEN_6 = 1,        
    UART_LEN_7 = 2,        
    UART_LEN_8 = 3         
} UART_LEN;

typedef enum UART_STOP {
    UART_STOP_ONE = 0,  
    UART_STOP_TWO = 1   
} UART_STOP;

typedef enum UART_PAR {
    UART_PAR_NONE = 0,  
    UART_PAR_EVEN = 1,  
    UART_PAR_ODD  = 2,  
    UART_PAR_ZERO = 3,  
    UART_PAR_ONE  = 4   
} UART_PAR;

typedef struct UART_Params {
    UART_Mode         readMode;         
    UART_Mode         writeMode;        
    unsigned int      readTimeout;      
    unsigned int      writeTimeout;     
    UART_Callback     readCallback;     
    UART_Callback     writeCallback;    
    UART_ReturnMode   readReturnMode;   
    UART_DataMode     readDataMode;     
    UART_DataMode     writeDataMode;    
    UART_Echo         readEcho;         
    uint32_t          baudRate;         
    UART_LEN          dataLength;       
    UART_STOP         stopBits;         
    UART_PAR          parityType;       
    uintptr_t         custom;           
} UART_Params;

typedef void        (*UART_CloseFxn)          (UART_Handle handle);

typedef int         (*UART_ControlFxn)        (UART_Handle handle,
                                               unsigned int cmd,
                                               void *arg);

typedef void        (*UART_InitFxn)           (UART_Handle handle);

typedef UART_Handle (*UART_OpenFxn)           (UART_Handle handle,
                                               UART_Params *params);
typedef int     (*UART_ReadFxn)           (UART_Handle handle, void *buffer,
                                           size_t size);

typedef int     (*UART_ReadPollingFxn)    (UART_Handle handle, void *buffer,
                                           size_t size);

typedef void    (*UART_ReadCancelFxn)     (UART_Handle handle);

typedef int     (*UART_WriteFxn)          (UART_Handle handle,
                                           const void *buffer,
                                           size_t size);

typedef int     (*UART_WritePollingFxn)   (UART_Handle handle,
                                           const void *buffer,
                                           size_t size);

typedef void    (*UART_WriteCancelFxn)    (UART_Handle handle);

typedef struct UART_FxnTable {
    UART_CloseFxn           closeFxn;

    UART_ControlFxn         controlFxn;

    UART_InitFxn            initFxn;

    UART_OpenFxn            openFxn;

    UART_ReadFxn            readFxn;

    UART_ReadPollingFxn     readPollingFxn;

    UART_ReadCancelFxn      readCancelFxn;

    UART_WriteFxn           writeFxn;

    UART_WritePollingFxn    writePollingFxn;

    UART_WriteCancelFxn     writeCancelFxn;
} UART_FxnTable;

typedef struct UART_Config {
    UART_FxnTable const    *fxnTablePtr;

    void                   *object;

    void          const    *hwAttrs;
} UART_Config;

extern void UART_close(UART_Handle handle);

extern int UART_control(UART_Handle handle, unsigned int cmd, void *arg);

extern void UART_init(void);

extern UART_Handle UART_open(unsigned int index, UART_Params *params);

extern void UART_Params_init(UART_Params *params);

extern int UART_write(UART_Handle handle, const void *buffer, size_t size);

extern int UART_writePolling(UART_Handle handle, const void *buffer,
                             size_t size);

extern void UART_writeCancel(UART_Handle handle);

extern int UART_read(UART_Handle handle, void *buffer, size_t size);

extern int UART_readPolling(UART_Handle handle, void *buffer, size_t size);

extern void UART_readCancel(UART_Handle handle);

#ifdef __cplusplus
}
#endif

#endif /* ti_drivers_UART__include */