uart.h

Go to the documentation of this file.

/* Copyright 2014, Peter A. Bigot
 *
 * 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 the software 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 HOLDER 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 BSPACM_PERIPH_UART_H
#define BSPACM_PERIPH_UART_H

#include <bspacm/core.h>

/* Forward declaration */
struct sBSPACMperiphUARToperations;
struct sFIFO;

typedef struct sBSPACMperiphUARTstate {
  void * const uart;

  union {
    uint32_t u32;               
    const void * ptr;           
  } const devcfg;

  const struct sBSPACMperiphUARToperations * const ops;

  struct sFIFO * const tx_fifo_ni_;

  struct sFIFO * const rx_fifo_ni_;

  unsigned int flags;

  unsigned int peripheral_state_ni;

  unsigned int rx_count;

  unsigned int tx_count;

  uint16_t rx_dropped_errors;

  uint8_t rx_frame_errors;

  uint8_t rx_parity_errors;

  uint8_t rx_break_errors;

  uint8_t rx_overrun_errors;

  uint8_t tx_state_;
} sBSPACMperiphUARTstate;

typedef sBSPACMperiphUARTstate * hBSPACMperiphUART;

typedef struct sBSPACMperiphUARTconfiguration {
  unsigned int speed_baud;
} sBSPACMperiphUARTconfiguration;

typedef enum eBSPACMperiphUARTfifoState {
  eBSPACMperiphUARTfifoState_HWRX = 0x01,

  eBSPACMperiphUARTfifoState_HWTX = 0x02,

  eBSPACMperiphUARTfifoState_HW = ((unsigned int)eBSPACMperiphUARTfifoState_HWRX
                                   | (unsigned int)eBSPACMperiphUARTfifoState_HWTX),

  eBSPACMperiphUARTfifoState_SWRX = 0x04,

  eBSPACMperiphUARTfifoState_SWTX = 0x08,

  /* There is no concept of driver-layer receive state. */

  eBSPACMperiphUARTfifoState_DRTX = 0x10,

  eBSPACMperiphUARTfifoState_TX = ((unsigned int)eBSPACMperiphUARTfifoState_DRTX
                                   | (unsigned int)eBSPACMperiphUARTfifoState_SWTX
                                   | (unsigned int)eBSPACMperiphUARTfifoState_HWTX),

  eBSPACMperiphUARTfifoState_RX = ((unsigned int)eBSPACMperiphUARTfifoState_SWRX
                                   | (unsigned int)eBSPACMperiphUARTfifoState_HWRX),
} eBSPACMperiphUARTfifoState;

typedef struct sBSPACMperiphUARToperations {
  int (* configure) (sBSPACMperiphUARTstate * usp,
                     const sBSPACMperiphUARTconfiguration * cfgp);

  int (* hw_transmit) (sBSPACMperiphUARTstate * usp, uint8_t v);

  void (* hw_txien) (sBSPACMperiphUARTstate * usp, int enablep);

  int (* fifo_state) (sBSPACMperiphUARTstate * usp);

} sBSPACMperiphUARToperations;

#define BSPACM_PERIPH_UART_FLAG_ONLCR 0x01

static BSPACM_CORE_INLINE
hBSPACMperiphUART
hBSPACMperiphUARTconfigure (hBSPACMperiphUART usp,
                            const sBSPACMperiphUARTconfiguration * cfgp)
{
  if (!!usp && (0 == usp->ops->configure(usp, cfgp))) {
    return usp;
  }
  return 0;
}

int iBSPACMperiphUARTread (hBSPACMperiphUART usp, void * buf, size_t count);

int iBSPACMperiphUARTwrite (hBSPACMperiphUART usp, const void * buf,  size_t count);

static BSPACM_CORE_INLINE
int iBSPACMperiphUARTfifoState (hBSPACMperiphUART usp)
{
  BSPACM_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv = -1;

  if (usp) {
    BSPACM_CORE_DISABLE_INTERRUPT();
    do {
      rv = usp->ops->fifo_state(usp);
      if (usp->tx_state_) {
        rv |= eBSPACMperiphUARTfifoState_DRTX;
      }
    } while (0);
    BSPACM_CORE_REENABLE_INTERRUPT(istate);
  }
  return rv;
}

int iBSPACMperiphUARTflush (hBSPACMperiphUART usp,
                            int fifo_mask);

extern const hBSPACMperiphUART hBSPACMdefaultUART;

#include <bspacm/periph/uart_.h>

#endif /* BSPACM_PERIPH_UART_H */