h8s_sci.c

Go to the documentation of this file.

//=============================================================================
//
//      h8s_sci.c
//
//      Simple driver for the H8S Serial Communication Interface (SCI)
//      for diagnostic serial communication.
//
//=============================================================================
//####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):   ysato
// Contributors:ysato, Uwe Kindler
// Date:        2003-12-06
// Description: Simple driver for the H8S Serial Communication Interface. The 
//              SCI is the same for all H8S variants so we define this here in
//              architecture hal
//
//####DESCRIPTIONEND####
//
//=============================================================================


//=============================================================================
//                            DOXYGEN FILE HEADER
//=============================================================================


//=============================================================================
//                                 INCLUDES
//=============================================================================
#include <pkgconf/hal.h>

#include <cyg/hal/hal_io.h>             // IO macros
#include <cyg/hal/hal_misc.h>           // Helper functions
#include <cyg/hal/hal_intr.h>           // HAL_ENABLE/MASK/UNMASK_INTERRUPTS
#include <cyg/hal/hal_arch.h>           // SAVE/RESTORE GP
#include <cyg/hal/hal_if.h>             // Calling-if API
#include <cyg/hal/mod_regs_sci.h>       // serial register definitions

#include <cyg/hal/h8s_sci.h>            // our header

//
// if the kernel is present then also the kernel API have to be present
// in order to use driver api
//
#if !defined(CYGPKG_KERNEL) || defined(CYGFUN_KERNEL_API_C) 
#include <cyg/hal/drv_api.h>            // CYG_ISR_HANDLED
#endif


//=============================================================================
//                            INITIALIZE SCI CHANNEL
//=============================================================================
void hal_sci_init_channel(void* chan)
{
    cyg_uint8  tmp;
    cyg_uint8 *base = ((channel_data_t *)chan)->base;

    //
    // Disable Tx/Rx interrupts, but enable Tx/Rx. Set 8-1-no parity an
    // Set speed to value stored in chan->baud_rate
    //
    HAL_WRITE_UINT8(base + _REG_SCSCR, CYGARC_REG_SCSCR_TE | CYGARC_REG_SCSCR_RE);
    HAL_WRITE_UINT8(base + _REG_SCSMR, 0);                           // 8-1-no parity.
    HAL_READ_UINT8(base + _REG_SCSMR, tmp);                          // now set baud rate
    tmp &= ~CYGARC_REG_SCSMR_CKSx_MASK;
    tmp |= CYGARC_SCBRR_CKSx(((channel_data_t *)chan)->baud_rate);
    HAL_WRITE_UINT8(base + _REG_SCSMR, tmp);
    HAL_WRITE_UINT8(base + _REG_SCBRR, CYGARC_SCBRR_N(((channel_data_t *)chan)->baud_rate));   
}


//=============================================================================
//                         READ CHARACTER NONBLOCKED
//
//=============================================================================
static cyg_bool hal_sci_getc_nonblock(void* __ch_data, cyg_uint8* ch)
{
    cyg_uint8 *base = ((channel_data_t*)__ch_data)->base;
    cyg_uint8  sr;

    HAL_READ_UINT8(base+ _REG_SCSSR, sr);
    //
    // check if we have an RX overrun
    //
    if (sr & CYGARC_REG_SCSSR_ORER) 
    {
        //
        // Serial RX overrun. Clear error and let caller try again.
        //
        HAL_WRITE_UINT8(base + _REG_SCSSR, 
                        CYGARC_REG_SCSSR_CLEARMASK & ~CYGARC_REG_SCSSR_ORER);
        return false;
    }
    //
    // if no char arrived leave immediatelly with false
    //
    if ((sr & CYGARC_REG_SCSSR_RDRF) == 0)
    {
        return false;
    }
    //
    // read the received char and clear buffer full flag
    //
    HAL_READ_UINT8(base+_REG_SCRDR, *ch);
    HAL_WRITE_UINT8(base+_REG_SCSSR, sr & ~CYGARC_REG_SCSSR_RDRF);     // Clear buffer full flag

    return true;
}


//=============================================================================
//                           POLL FOR CHARACTER
//=============================================================================
cyg_uint8 hal_sci_getc(void *__ch_data)
{
    cyg_uint8 ch;
    CYGARC_HAL_SAVE_GP();

    while(!hal_sci_getc_nonblock(__ch_data, &ch))
    {
        // do nothing
    }

    CYGARC_HAL_RESTORE_GP();
    return ch;
}


//=============================================================================
//                           WRITE CHARACTER
//=============================================================================
void hal_sci_putc(void *__ch_data, cyg_uint8 c)
{
    cyg_uint8 *base = ((channel_data_t*)__ch_data)->base;
    cyg_uint8  sr;


    CYGARC_HAL_SAVE_GP();
    //
    // wait until send register is empty
    //
    do 
    {
        HAL_READ_UINT8(base + _REG_SCSSR, sr);
    } 
    while ((sr & CYGARC_REG_SCSSR_TDRE) == 0);
    //
    // Write char into send register and clear the empty flag
    //
    HAL_WRITE_UINT8(base + _REG_SCTDR, c);
    HAL_WRITE_UINT8(base + _REG_SCSSR, sr & ~CYGARC_REG_SCSSR_TDRE); // Clear empty flag.
    //
    // Hang around until the character has been safely sent.
    //
    do 
    {
        HAL_READ_UINT8(base + _REG_SCSSR, sr);
    } 
    while ((sr & CYGARC_REG_SCSSR_TDRE) == 0);

    CYGARC_HAL_RESTORE_GP();
}

//
// If we use virtual vector table then we have to define some additional
// functions for the COMM tables within the virtual vector table
//
#if defined(CYGSEM_HAL_VIRTUAL_VECTOR_DIAG)

//=============================================================================
//                          WRITE BUFFER OF CHARACTERS
//=============================================================================
void hal_sci_write(void            *__ch_data, 
                   const cyg_uint8 *__buf, 
                   cyg_uint32       __len)
{
    CYGARC_HAL_SAVE_GP();
    //
    // Send buffer until detection of terminating zero
    //
    while(__len-- > 0)
    {
        hal_sci_putc(__ch_data, *__buf++);
    }

    CYGARC_HAL_RESTORE_GP();
}



//=============================================================================
//                          READ BUFFER OF CHARACTERS
//=============================================================================
void hal_sci_read(void      *__ch_data, 
                  cyg_uint8 *__buf, 
                  cyg_uint32 __len)
{
    CYGARC_HAL_SAVE_GP();
    //
    // Read a number of chars from SCI until __len ist counted down
    // to zero
    //
    while(__len-- > 0)
    {
        *__buf++ = hal_sci_getc(__ch_data);
    }

    CYGARC_HAL_RESTORE_GP();
}


//=============================================================================
//                       READ CHARACTER WITH TIMEOUT
//=============================================================================
cyg_bool hal_sci_getc_timeout(void *__ch_data, cyg_uint8 *ch)
{
    channel_data_t *chan = (channel_data_t*)__ch_data;
    int            delay_count;
    cyg_bool       res;


    CYGARC_HAL_SAVE_GP();

    delay_count = chan->msec_timeout * 20; // delay in .1 ms steps 
    //
    // Loop until we received a char or until time is over
    //
    while (1)
    {
        res = hal_sci_getc_nonblock(__ch_data, ch);
        if (res || (0 == delay_count--))
        {
            break;
        }
        
        CYGACC_CALL_IF_DELAY_US(50);
    }

    CYGARC_HAL_RESTORE_GP();
    return res;
}


//=============================================================================
//                          CONTROL SCI DEVICE
//=============================================================================
int hal_sci_control(void *__ch_data, __comm_control_cmd_t __func, ...)
{
    channel_data_t *chan      = (channel_data_t*)__ch_data;
    cyg_uint8       scr;
    int             ret       = 0;
    
    
    CYGARC_HAL_SAVE_GP();
    //
    // decide what we have to do according to the control command
    //
    switch (__func) 
    {
        //
        // Enable receive interrupts
        //
        case __COMMCTL_IRQ_ENABLE:
             HAL_READ_UINT8(chan->base+_REG_SCSCR, scr);
             scr |= CYGARC_REG_SCSCR_RIE;
             HAL_WRITE_UINT8(chan->base+_REG_SCSCR, scr);
             break;
        //
        // disable receive interrupts
        //
        case __COMMCTL_IRQ_DISABLE:
             HAL_READ_UINT8(chan->base+_REG_SCSCR, scr);
             scr &= ~CYGARC_REG_SCSCR_RIE;
             HAL_WRITE_UINT8(chan->base+_REG_SCSCR, scr);
             break;
        //
        // query isr vector of channel
        //
        case __COMMCTL_DBG_ISR_VECTOR:
             ret = chan->isr_vector;
             break;
        //
        // set new timeout and return the old one
        //
        case __COMMCTL_SET_TIMEOUT:
             {
                 va_list ap;

                 va_start(ap, __func);

                 ret = chan->msec_timeout;
                 chan->msec_timeout = va_arg(ap, cyg_uint32);

                 va_end(ap);
             } 
             break;
        //
        // set new baudrate for comm channel
        // 
        case __COMMCTL_SETBAUD:
             {
                cyg_uint32 baud_rate;
                cyg_uint8  tmp;
                va_list    ap;
                //
                // get baud rate from variable argument list
                //
                va_start(ap, __func);
                baud_rate = va_arg(ap, cyg_uint32);
                va_end(ap);
                //
                // disable sci interrupts while changing the hardware
                //
                HAL_READ_UINT8(chan->base + _REG_SCSCR, scr);
                tmp = scr;
                tmp = scr & ~(CYGARC_REG_SCSCR_TIE 
                            | CYGARC_REG_SCSCR_RIE
                            | CYGARC_REG_SCSCR_MPIE
                            | CYGARC_REG_SCSCR_TEIE);
                HAL_WRITE_UINT8(chan->base + _REG_SCSCR, tmp);
                //
                // Now set new baud rate - we have to set BRR and CKS in SCSMR
                //
                HAL_READ_UINT8(chan->base + _REG_SCSMR, tmp);                          
                tmp &= ~CYGARC_REG_SCSMR_CKSx_MASK;
                tmp |= CYGARC_SCBRR_CKSx(baud_rate);
                HAL_WRITE_UINT8(chan->base + _REG_SCSMR, tmp);
                HAL_WRITE_UINT8(chan->base + _REG_SCBRR, CYGARC_SCBRR_N(baud_rate));
                //
                // now restore old scr register settings before disabling interrupts
                //
                HAL_WRITE_UINT8(chan->base + _REG_SCSCR, scr);
             } 
             break; // End of case __COMMCTL_SETBAUD: 
        //
        // Query baud rate
        //
        case __COMMCTL_GETBAUD:
             break; 
        //
        //
        //  
        default:
             ; // do nothing
    } // End of switch (__func) 

    CYGARC_HAL_RESTORE_GP();
    return ret;
}


//=============================================================================
//                          INTERRUPT HANDLER
//=============================================================================
int hal_sci_isr(void         *__ch_data, 
                int          *__ctrlc, 
                CYG_ADDRWORD  __vector, 
                CYG_ADDRWORD  __data)
{
    cyg_uint8  c; 
    cyg_uint8  sr;
    cyg_uint8 *base = ((channel_data_t*)__ch_data)->base;
    int        res  = 0;


    CYGARC_HAL_SAVE_GP();

    *__ctrlc = 0;
    HAL_READ_UINT8(base + _REG_SCSSR, sr);
    if (sr & CYGARC_REG_SCSSR_ORER) 
    {
        //
        // Serial RX overrun. Clear error and hope protocol recovers.
        //
        HAL_WRITE_UINT8(base+_REG_SCSSR, 
                        CYGARC_REG_SCSSR_CLEARMASK & ~CYGARC_REG_SCSSR_ORER);
        res = CYG_ISR_HANDLED;
    } 
    else if (sr & CYGARC_REG_SCSSR_RDRF) 
    {
        
        HAL_READ_UINT8(base+_REG_SCRDR, c);     // Received character
        HAL_WRITE_UINT8(base+_REG_SCSSR,        // Clear buffer full flag.
                        CYGARC_REG_SCSSR_CLEARMASK & ~CYGARC_REG_SCSSR_RDRF);

        if(cyg_hal_is_break(&c, 1 ))
        {
            *__ctrlc = 1;
        }

        res = CYG_ISR_HANDLED;
    }

    CYGARC_HAL_RESTORE_GP();
    return res;
}
#endif // End of #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_DIAG

//-----------------------------------------------------------------------------
// end of sci.c

---