#ifndef CYGONCE_SERIAL_H #define CYGONCE_SERIAL_H // ==================================================================== // // serial.h // // Device I/O // // ==================================================================== //####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. // // eCos is free software; you can redistribute it and/or modify it under // the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 or (at your option) any later version. // // eCos is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License along // with eCos; if not, write to the Free Software Foundation, Inc., // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. // // As a special exception, if other files instantiate templates or use macros // or inline functions from this file, or you compile this file and link it // with other works to produce a work based on this file, this file does not // by itself cause the resulting work to be covered by the GNU General Public // License. However the source code for this file must still be made available // in accordance with section (3) of the GNU General Public License. // // This exception does not invalidate any other reasons why a work based on // this file might be covered by the GNU General Public License. // // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. // at http://sources.redhat.com/ecos/ecos-license/ // ------------------------------------------- //####ECOSGPLCOPYRIGHTEND#### // ==================================================================== //#####DESCRIPTIONBEGIN#### // // Author(s): gthomas // Contributors: gthomas // Date: 1999-02-04 // Purpose: Internal interfaces for serial I/O drivers // Description: // //####DESCRIPTIONEND#### // // ==================================================================== // Serial I/O interfaces #include #include #include #include #include #include #include #ifdef CYGPKG_IO_SERIAL_SELECT_SUPPORT #include #endif typedef struct serial_channel serial_channel; typedef struct serial_funs serial_funs; // The block transfer request functions may fail for one of two // reasons. It's important for the caller to know which. typedef enum { CYG_RCV_OK, CYG_RCV_FULL, CYG_RCV_DISABLED } rcv_req_reply_t; typedef enum { CYG_XMT_OK, CYG_XMT_EMPTY, CYG_XMT_DISABLED } xmt_req_reply_t; // Pointers into upper-level driver which interrupt handlers need typedef struct { // Initialize the channel void (*serial_init)(serial_channel *chan); // Cause an additional character to be output if one is available void (*xmt_char)(serial_channel *chan); // Consume an input character void (*rcv_char)(serial_channel *chan, unsigned char c); #if CYGINT_IO_SERIAL_BLOCK_TRANSFER // Request space for input characters rcv_req_reply_t (*data_rcv_req)(serial_channel *chan, int avail, int* space_avail, unsigned char** space); // Receive operation completed void (*data_rcv_done)(serial_channel *chan, int chars_rcvd); // Request characters for transmission xmt_req_reply_t (*data_xmt_req)(serial_channel *chan, int space, int* chars_avail, unsigned char** chars); // Transmit operation completed void (*data_xmt_done)(serial_channel *chan, int chars_sent); #endif #if defined(CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS) void (*indicate_status)(serial_channel *chan, cyg_serial_line_status_t *s ); #endif } serial_callbacks_t; #if CYGINT_IO_SERIAL_BLOCK_TRANSFER # ifdef CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS # define SERIAL_CALLBACKS(_l,_init,_xmt_char,_rcv_char, _data_rcv_req, _data_rcv_done, _data_xmt_req, _data_xmt_done, _indicate_status) \ serial_callbacks_t _l = { \ _init, \ _xmt_char, \ _rcv_char, \ _data_rcv_req, \ _data_rcv_done, \ _data_xmt_req, \ _data_xmt_done, \ _indicate_status \ }; # else # define SERIAL_CALLBACKS(_l,_init,_xmt_char,_rcv_char, _data_rcv_req, _data_rcv_done, _data_xmt_req, _data_xmt_done) \ serial_callbacks_t _l = { \ _init, \ _xmt_char, \ _rcv_char, \ _data_rcv_req, \ _data_rcv_done, \ _data_xmt_req, \ _data_xmt_done \ }; # endif #else # ifdef CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS # define SERIAL_CALLBACKS(_l,_init,_xmt_char,_rcv_char,_indicate_status) \ serial_callbacks_t _l = { \ _init, \ _xmt_char, \ _rcv_char, \ _indicate_status \ }; # else # define SERIAL_CALLBACKS(_l,_init,_xmt_char,_rcv_char) \ serial_callbacks_t _l = { \ _init, \ _xmt_char, \ _rcv_char \ }; # endif #endif extern serial_callbacks_t cyg_io_serial_callbacks; typedef struct { unsigned char *data; volatile int put; volatile int get; int len; volatile int nb; // count of bytes currently in buffer int low_water; // For tx: min space in buffer before restart // For rx: max buffer used before flow unthrottled #ifdef CYGPKG_IO_SERIAL_FLOW_CONTROL int high_water; // For tx: unused // For rx: min buffer used before throttle #endif cyg_drv_cond_t wait; cyg_drv_mutex_t lock; bool waiting; #ifdef CYGOPT_IO_SERIAL_SUPPORT_NONBLOCKING bool blocking; #endif volatile bool abort; // Set by an outsider to kill processing volatile cyg_int32 pending; // This many bytes waiting to be sent #ifdef CYGPKG_IO_SERIAL_SELECT_SUPPORT struct CYG_SELINFO_TAG selinfo; // select info #endif #ifdef CYGDBG_USE_ASSERTS #ifdef CYGINT_IO_SERIAL_BLOCK_TRANSFER bool block_mode_xfer_running; #endif // CYGINT_IO_SERIAL_BLOCK_TRANSFER #endif // CYGDBG_USE_ASSERTS } cbuf_t; #define CBUF_INIT(_data, _len) \ {_data, 0, 0, _len} #ifdef CYGPKG_IO_SERIAL_FLOW_CONTROL typedef struct { cyg_uint32 flags; #ifdef CYGOPT_IO_SERIAL_FLOW_CONTROL_SOFTWARE cyg_uint8 xchar; #endif } flow_desc_t; #endif // Private data which describes this channel struct serial_channel { serial_funs *funs; serial_callbacks_t *callbacks; void *dev_priv; // Whatever is needed by actual device routines cyg_serial_info_t config; // Current configuration bool init; cbuf_t out_cbuf; cbuf_t in_cbuf; #ifdef CYGPKG_IO_SERIAL_FLOW_CONTROL flow_desc_t flow_desc; #endif #ifdef CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS cyg_serial_line_status_callback_fn_t status_callback; CYG_ADDRWORD status_callback_priv; #endif }; // Flow descriptor flag values #define CYG_SERIAL_FLOW_OUT_THROTTLED (1<<0) #define CYG_SERIAL_FLOW_IN_THROTTLED (1<<1) // Initialization macro for serial channel #define SERIAL_CHANNEL(_l, \ _funs, \ _dev_priv, \ _baud, _stop, _parity, _word_length, _flags) \ serial_channel _l = { \ &_funs, \ &cyg_io_serial_callbacks, \ &(_dev_priv), \ CYG_SERIAL_INFO_INIT(_baud, _stop, _parity, _word_length, _flags), \ }; #define SERIAL_CHANNEL_USING_INTERRUPTS(_l, \ _funs, \ _dev_priv, \ _baud, _stop, _parity, _word_length, _flags, \ _out_buf, _out_buflen, \ _in_buf, _in_buflen) \ serial_channel _l = { \ &_funs, \ &cyg_io_serial_callbacks, \ &(_dev_priv), \ CYG_SERIAL_INFO_INIT(_baud, _stop, _parity, _word_length, _flags), \ false, \ CBUF_INIT(_out_buf, _out_buflen), \ CBUF_INIT(_in_buf, _in_buflen) \ }; // Low level interface functions struct serial_funs { // Send one character to the output device, return true if consumed bool (*putc)(serial_channel *priv, unsigned char c); // Fetch one character from the device unsigned char (*getc)(serial_channel *priv); // Change hardware configuration (baud rate, etc) Cyg_ErrNo (*set_config)(serial_channel *priv, cyg_uint32 key, const void *xbuf, cyg_uint32 *len); // Enable the transmit channel and turn on transmit interrupts void (*start_xmit)(serial_channel *priv); // Disable the transmit channel and turn transmit interrupts off void (*stop_xmit)(serial_channel *priv); }; #define SERIAL_FUNS(_l,_putc,_getc,_set_config,_start_xmit,_stop_xmit) \ serial_funs _l = { \ _putc, \ _getc, \ _set_config, \ _start_xmit, \ _stop_xmit \ }; extern cyg_devio_table_t cyg_io_serial_devio; #endif // CYGONCE_SERIAL_H