Changeset da2fc6c0 in rtems


Ignore:
Timestamp:
Sep 11, 2006, 9:43:56 PM (14 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
b18803f
Parents:
1883c87
Message:

2006-09-11 Joel Sherrill <joel@…>

  • console/console.c, console/sci.c, console/sci.h, spurious/spinit.c, startup/bspclean.c, startup/start_c.c: Convert C++ style comments to C style.
Location:
c/src/lib/libbsp/m68k/mrm332
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/m68k/mrm332/ChangeLog

    r1883c87 rda2fc6c0  
     12006-09-11      Joel Sherrill <joel@OARcorp.com>
     2
     3        * console/console.c, console/sci.c, console/sci.h, spurious/spinit.c,
     4        startup/bspclean.c, startup/start_c.c: Convert C++ style comments to
     5        C style.
     6
    172006-02-08      Joel Sherrill <joel@OARcorp.com>
    28
  • c/src/lib/libbsp/m68k/mrm332/console/console.c

    r1883c87 rda2fc6c0  
    1919#include <termios.h>
    2020#include "sci.h"
    21 //#include "../../../../../../rtems/c/src/lib/libbsp/m68k/opti/console/duart.h"
    22 //#include "../../../../../../rtems/c/src/lib/libc/libio_.h"
    2321
    2422/*PAGE
  • c/src/lib/libbsp/m68k/mrm332/console/sci.c

    r1883c87 rda2fc6c0  
    3737*
    3838*****************************************************************************/
    39 
    40 
    41 
    42 /*****************************************************************************
    43   Compiler Options for the incurably curious
    44 *****************************************************************************/
    45 
    46 /*
    47 /opt/rtems/bin/m68k-rtems-gcc
    48     --pipe                                      # use pipes, not tmp files
    49     -B../../../../../../../../opti/lib/         # where the library is
    50     -specs bsp_specs                            # ???
    51     -qrtems                                     # ???
    52     -g                                          # add debugging info
    53     -Wall                                       # issue all warnings
    54     -fasm                                       # allow inline asm???
    55     -DCONSOLE_SCI                               # for opti-r box/rev b proto
    56     -mcpu32                                     # machine = motorola cpu 32
    57     -c                                          # compile, don't link
    58     -O4                                         # max optimization
    59     -fomit-frame-pointer                        # stack frames are optional
    60     -o o-optimize/sci.o                         # the object file
    61     ../../../../../../../../../rtems/c/src/lib/libbsp/m68k/opti/console/sci.c
    62 */
    63 
    6439
    6540
     
    11691#include <libchip/sersupp.h>
    11792#include "sci.h"
    118 //#include "../misc/include/cpu332.h"
     93/*#include "../misc/include/cpu332.h" */
    11994
    12095
     
    12499*****************************************************************************/
    125100
    126 #define SCI_MINOR       0                   // minor device number
    127 
    128 // IMPORTANT - if the device driver api is opened, it means the sci is being
    129 // used for direct hardware access, so other users (like termios) get ignored
    130 
    131 #define DRIVER_CLOSED   0                   // the device driver api is closed
    132 #define DRIVER_OPENED   1                   // the device driver api is opened
    133 
    134 // system clock definitions, i dont have documentation on this...
    135 
    136 #if 0 // Not needed, this is provided in mrm332.h
    137 #define XTAL            32768.0                 // crystal frequency in Hz
    138 #define NUMB_W          0                               // system clock parameters
     101#define SCI_MINOR       0                   /* minor device number */
     102
     103/* IMPORTANT - if the device driver api is opened, it means the sci is being
     104 * used for direct hardware access, so other users (like termios) get ignored
     105 */
     106#define DRIVER_CLOSED   0                   /* the device driver api is closed */
     107#define DRIVER_OPENED   1                   /* the device driver api is opened */
     108
     109/* system clock definitions, i dont have documentation on this... */
     110
     111#if 0 /* Not needed, this is provided in mrm332.h */
     112#define XTAL            32768.0    /* crystal frequency in Hz */
     113#define NUMB_W          0          /* system clock parameters */
    139114#define NUMB_X          1
    140 //efine NUMB_Y          0x38                    // for 14.942 Mhz
    141 #define NUMB_Y          0x3F                        // for 16.777 Mhz
     115#define NUMB_Y          0x38       /* for 14.942 Mhz */
     116#define NUMB_Y          0x3F       /* for 16.777 Mhz */
    142117
    143118#define SYS_CLOCK       (XTAL * 4.0 * (NUMB_Y+1) * (1 << (2 * NUMB_W + NUMB_X)))
     
    167142void SCI_output_char(char c);
    168143
    169 rtems_isr SciIsr( rtems_vector_number vector );         // interrupt handler
     144/*rtems_isr SciIsr( rtems_vector_number vector );   interrupt handler */
    170145
    171146const rtems_termios_callbacks * SciGetTermiosHandlers( int32_t   polled );
    172147
    173 rtems_device_driver SciInitialize ();                   // device driver api
    174 rtems_device_driver SciOpen ();                         // device driver api
    175 rtems_device_driver SciClose ();                        // device driver api
    176 rtems_device_driver SciRead ();                         // device driver api
    177 rtems_device_driver SciWrite ();                        // device driver api
    178 rtems_device_driver SciControl ();                      // device driver api
    179 
    180 int32_t   SciInterruptOpen();                            // termios api
    181 int32_t   SciInterruptClose();                           // termios api
    182 int32_t   SciInterruptWrite();                           // termios api
    183 
    184 int32_t   SciSetAttributes();                            // termios api
    185 
    186 int32_t   SciPolledOpen();                               // termios api
    187 int32_t   SciPolledClose();                              // termios api
    188 int32_t   SciPolledRead();                               // termios api
    189 int32_t   SciPolledWrite();                              // termios api
    190 
    191 static void SciSetBaud(uint32_t   rate);                // hardware routine
    192 static void SciSetDataBits(uint16_t   bits);            // hardware routine
    193 static void SciSetParity(uint16_t   parity);            // hardware routine
    194 
    195 static void inline SciDisableAllInterrupts( void );     // hardware routine
    196 static void inline SciDisableTransmitInterrupts( void );// hardware routine
    197 static void inline SciDisableReceiveInterrupts( void ); // hardware routine
    198 
    199 static void inline SciEnableTransmitInterrupts( void ); // hardware routine
    200 static void inline SciEnableReceiveInterrupts( void );  // hardware routine
    201 
    202 static void inline SciDisableReceiver( void );          // hardware routine
    203 static void inline SciDisableTransmitter( void );       // hardware routine
    204 
    205 static void inline SciEnableReceiver( void );           // hardware routine
    206 static void inline SciEnableTransmitter( void );        // hardware routine
    207 
    208 void SciWriteCharWait  ( uint8_t);                   // hardware routine
    209 void SciWriteCharNoWait( uint8_t);                   // hardware routine
    210 
    211 uint8_t   inline SciCharAvailable( void );              // hardware routine
    212 
    213 uint8_t   inline SciReadCharWait( void );               // hardware routine
    214 uint8_t   inline SciReadCharNoWait( void );             // hardware routine
    215 
    216 void SciSendBreak( void );                              // test routine
    217 
    218 static int8_t   SciRcvBufGetChar();                      // circular rcv buf
    219 static void    SciRcvBufPutChar( uint8_t);           // circular rcv buf
    220 //atic void    SciRcvBufFlush( void );                  // circular rcv buf
    221 
    222 void SciUnitTest();                                     // test routine
    223 void SciPrintStats();                                   // test routine
     148rtems_device_driver SciInitialize(                     /* device driver api */
     149    rtems_device_major_number, rtems_device_minor_number, void *);
     150rtems_device_driver SciOpen(                           /* device driver api */
     151    rtems_device_major_number, rtems_device_minor_number, void *);
     152rtems_device_driver SciClose(                          /* device driver api */
     153    rtems_device_major_number, rtems_device_minor_number, void *);
     154rtems_device_driver SciRead(                           /* device driver api */
     155    rtems_device_major_number, rtems_device_minor_number, void *);
     156rtems_device_driver SciWrite(                          /* device driver api */
     157    rtems_device_major_number, rtems_device_minor_number, void *);
     158rtems_device_driver SciControl(                        /* device driver api */
     159    rtems_device_major_number, rtems_device_minor_number, void *);
     160rtems_device_driver SciRead (
     161    rtems_device_major_number, rtems_device_minor_number, void *);
     162
     163int   SciInterruptOpen(int, int, void *);               /* termios api */
     164int   SciInterruptClose(int, int, void *);              /* termios api */
     165int   SciInterruptWrite(int, const char *, int);        /* termios api */
     166
     167int   SciSetAttributes(int, const struct termios*);     /* termios api */
     168int   SciPolledOpen(int, int, void *);                  /* termios api */
     169int   SciPolledClose(int, int, void *);                 /* termios api */
     170int   SciPolledRead(int);                               /* termios api */
     171int   SciPolledWrite(int, const char *, int);           /* termios api */
     172
     173static void SciSetBaud(uint32_t   rate);                /* hardware routine */
     174static void SciSetDataBits(uint16_t   bits);            /* hardware routine */
     175static void SciSetParity(uint16_t   parity);            /* hardware routine */
     176
     177static void inline SciDisableAllInterrupts( void );     /* hardware routine */
     178static void inline SciDisableTransmitInterrupts( void );/* hardware routine */
     179static void inline SciDisableReceiveInterrupts( void ); /* hardware routine */
     180
     181static void inline SciEnableTransmitInterrupts( void ); /* hardware routine */
     182static void inline SciEnableReceiveInterrupts( void );  /* hardware routine */
     183
     184static void inline SciDisableReceiver( void );          /* hardware routine */
     185static void inline SciDisableTransmitter( void );       /* hardware routine */
     186
     187static void inline SciEnableReceiver( void );           /* hardware routine */
     188static void inline SciEnableTransmitter( void );        /* hardware routine */
     189
     190void SciWriteCharWait  ( uint8_t );                     /* hardware routine */
     191void SciWriteCharNoWait( uint8_t );                     /* hardware routine */
     192
     193uint8_t   inline SciCharAvailable( void );              /* hardware routine */
     194
     195uint8_t   inline SciReadCharWait( void );               /* hardware routine */
     196uint8_t   inline SciReadCharNoWait( void );             /* hardware routine */
     197
     198void SciSendBreak( void );                              /* test routine */
     199
     200static int8_t   SciRcvBufGetChar();                     /* circular rcv buf */
     201static void    SciRcvBufPutChar( uint8_t);              /* circular rcv buf */
     202#if 0
     203static void    SciRcvBufFlush( void );                  /* unused routine */
     204#endif
     205
     206void SciUnitTest();                                     /* test routine */
     207void SciPrintStats();                                   /* test routine */
    224208
    225209
     
    231215static struct rtems_termios_tty *SciTermioTty;
    232216
    233 static uint8_t   SciInited = 0;             // has the driver been inited
    234 
    235 static uint8_t   SciOpened;                 // has the driver been opened
    236 
    237 static uint8_t   SciMajor;                  // major device number
    238 
    239 static uint16_t   SciBaud;                  // current value in baud register
    240 
    241 static uint32_t   SciBytesIn  = 0;          // bytes received
    242 static uint32_t   SciBytesOut = 0;          // bytes transmitted
    243 
    244 static uint32_t   SciErrorsParity  = 0;     // error counter
    245 static uint32_t   SciErrorsNoise   = 0;     // error counter
    246 static uint32_t   SciErrorsFraming = 0;     // error counter
    247 static uint32_t   SciErrorsOverrun = 0;     // error counter
     217static uint8_t   SciInited = 0;             /* has the driver been inited */
     218
     219static uint8_t   SciOpened;                 /* has the driver been opened */
     220
     221static uint8_t   SciMajor;                  /* major device number */
     222
     223static uint16_t   SciBaud;                  /* current value in baud register */
     224
     225static uint32_t   SciBytesIn  = 0;          /* bytes received */
     226static uint32_t   SciBytesOut = 0;          /* bytes transmitted */
     227
     228static uint32_t   SciErrorsParity  = 0;     /* error counter */
     229static uint32_t   SciErrorsNoise   = 0;     /* error counter */
     230static uint32_t   SciErrorsFraming = 0;     /* error counter */
     231static uint32_t   SciErrorsOverrun = 0;     /* error counter */
    248232
    249233#if defined(CONSOLE_SCI)
    250234
    251 // this is what rtems printk uses to do polling based output
     235/* this is what rtems printk uses to do polling based output */
    252236
    253237BSP_output_char_function_type      BSP_output_char = SCI_output_char;
     
    256240#endif
    257241
    258 // cvs id string so you can use the unix ident command on the object
     242/* cvs id string so you can use the unix ident command on the object */
    259243
    260244#ifdef ID_STRINGS
     
    268252*****************************************************************************/
    269253
    270 // it is trivial to wrap your buffer pointers when size is a power of two
    271 
    272 #define SCI_RCV_BUF_SIZE        256         // must be a power of 2 !!!
    273 
    274 // if someone opens the sci device using the device driver interface,
    275 // then the receive data interrupt handler will put characters in this buffer
    276 // instead of sending them up to the termios module for the console
    277 
     254/* it is trivial to wrap your buffer pointers when size is a power of two */
     255
     256#define SCI_RCV_BUF_SIZE        256         /* must be a power of 2 !!! */
     257
     258/* if someone opens the sci device using the device driver interface,
     259 * then the receive data interrupt handler will put characters in this buffer
     260 * instead of sending them up to the termios module for the console
     261 */
    278262static uint8_t   SciRcvBuffer[SCI_RCV_BUF_SIZE];
    279263
    280 static uint8_t   SciRcvBufPutIndex = 0;     // array index to put in next char
    281 
    282 static uint8_t   SciRcvBufGetIndex = 0;     // array index to take out next char
    283 
    284 static uint16_t  SciRcvBufCount = 0;        // how many bytes are in the buffer
     264static uint8_t   SciRcvBufPutIndex = 0; /* array index to put in next char */
     265
     266static uint8_t   SciRcvBufGetIndex = 0; /* array index to take out next char */
     267
     268static uint16_t  SciRcvBufCount = 0;   /* how many bytes are in the buffer */
    285269
    286270
     
    293277static const rtems_termios_callbacks SciInterruptCallbacks =
    294278{
    295     SciInterruptOpen,                       // first open
    296     SciInterruptClose,                      // last close
    297     NULL,                                   // polled read (not required)
    298     SciInterruptWrite,                      // write
    299     SciSetAttributes,                       // set attributes
    300     NULL,                                   // stop remote xmit
    301     NULL,                                   // start remote xmit
    302     TRUE                                    // output uses interrupts
     279    SciInterruptOpen,                       /* first open */
     280    SciInterruptClose,                      /* last close */
     281    NULL,                                   /* polled read (not required) */
     282    SciInterruptWrite,                      /* write */
     283    SciSetAttributes,                       /* set attributes */
     284    NULL,                                   /* stop remote xmit */
     285    NULL,                                   /* start remote xmit */
     286    TRUE                                    /* output uses interrupts */
    303287};
    304288
     
    309293static const rtems_termios_callbacks SciPolledCallbacks =
    310294{
    311     SciPolledOpen,                          // first open
    312     SciPolledClose,                         // last close
    313     SciPolledRead,                          // polled read
    314     SciPolledWrite,                         // write
    315     SciSetAttributes,                       // set attributes
    316     NULL,                                   // stop remote xmit
    317     NULL,                                   // start remote xmit
    318     FALSE                                   // output uses interrupts
     295    SciPolledOpen,                          /* first open */
     296    SciPolledClose,                         /* last close */
     297    SciPolledRead,                          /* polled read */
     298    SciPolledWrite,                         /* write */
     299    SciSetAttributes,                       /* set attributes */
     300    NULL,                                   /* stop remote xmit */
     301    NULL,                                   /* start remote xmit */
     302    FALSE                                   /* output uses interrupts */
    319303};
    320304
    321305
    322306
    323 /////////////////////////////////////////////////////////////////////////////
    324 //
    325 //                              SECTION 0
    326 //                        MISCELLANEOUS ROUTINES
    327 //
    328 /////////////////////////////////////////////////////////////////////////////
    329 
    330 /****************************************************************************
    331 * Func:     SCI_output_char
    332 * Desc:     used by rtems printk function to send a char to the uart
    333 * Inputs:   the character to transmit
    334 * Outputs:  none
    335 * Errors:   none
    336 * Scope:    public
    337 ****************************************************************************/
     307/*
     308 *                              SECTION 0
     309 *                        MISCELLANEOUS ROUTINES
     310 */
     311
     312/****************************************************************************
     313 * Func:     SCI_output_char
     314 * Desc:     used by rtems printk function to send a char to the uart
     315 * Inputs:   the character to transmit
     316 * Outputs:  none
     317 * Errors:   none
     318 * Scope:    public
     319 ****************************************************************************/
    338320
    339321void SCI_output_char(char c)
    340322{
    341 //  ( minor device number, pointer to the character, length )
     323/*  ( minor device number, pointer to the character, length ) */
    342324
    343325    SciPolledWrite( SCI_MINOR, &c, 1);
     
    362344    if ( polled )
    363345    {
    364         return &SciPolledCallbacks;             // polling based
     346        return &SciPolledCallbacks;             /* polling based */
    365347    }
    366348    else
    367349    {
    368         return &SciInterruptCallbacks;          // interrupt driven
     350        return &SciInterruptCallbacks;          /* interrupt driven */
    369351    }
    370352}
     
    390372    if ( (*SCSR) & SCI_ERROR_OVERRUN )   SciErrorsOverrun ++;
    391373
    392     // see if it was a transmit interrupt
    393 
    394     if ( (*SCSR) & SCI_XMTR_AVAILABLE )         // data reg empty, xmt complete
     374    /* see if it was a transmit interrupt */
     375
     376    if ( (*SCSR) & SCI_XMTR_AVAILABLE )         /* data reg empty, xmt complete */
    395377    {
    396378        SciDisableTransmitInterrupts();
    397379
    398         // tell termios module that the charcter was sent
    399         // he will call us later to transmit more if there are any
     380        /* tell termios module that the charcter was sent */
     381        /* he will call us later to transmit more if there are any */
    400382
    401383        if (rtems_termios_dequeue_characters( SciTermioTty, 1 ))
    402384        {
    403             // there are more bytes to transmit so enable TX interrupt
     385            /* there are more bytes to transmit so enable TX interrupt */
    404386
    405387            SciEnableTransmitInterrupts();
     
    407389    }
    408390
    409     // see if it was a receive interrupt
    410     // on the sci uart we just get one character per interrupt
    411 
    412     while (  SciCharAvailable() )               // char in data register?
    413     {
    414         ch = SciReadCharNoWait();               // get the char from the uart
    415 
    416         // IMPORTANT!!!
    417         // either send it to the termios module or keep it locally
    418 
    419         if ( SciOpened == DRIVER_OPENED )       // the driver is open
     391    /* see if it was a receive interrupt */
     392    /* on the sci uart we just get one character per interrupt */
     393
     394    while (  SciCharAvailable() )               /* char in data register? */
     395    {
     396        ch = SciReadCharNoWait();               /* get the char from the uart */
     397
     398        /* IMPORTANT!!! */
     399        /* either send it to the termios module or keep it locally */
     400
     401        if ( SciOpened == DRIVER_OPENED )       /* the driver is open */
    420402        {
    421             SciRcvBufPutChar(ch);               // keep it locally
     403            SciRcvBufPutChar(ch);               /* keep it locally */
    422404        }
    423         else                                    // put in termios buffer
     405        else                                    /* put in termios buffer */
    424406        {
    425             rtems_termios_enqueue_raw_characters( SciTermioTty, &ch, 1 );
     407            char c = (char) ch;
     408            rtems_termios_enqueue_raw_characters( SciTermioTty, &c, 1 );
    426409        }
    427410
    428         *SCSR &= SCI_CLEAR_RX_INT;              // clear the interrupt
    429     }
    430 }
    431 
    432 
    433 
    434 /////////////////////////////////////////////////////////////////////////////
    435 //
    436 //                              SECTION 1
    437 //                ROUTINES TO MANIPULATE THE CIRCULAR BUFFER
    438 //
    439 /////////////////////////////////////////////////////////////////////////////
     411        *SCSR &= SCI_CLEAR_RX_INT;              /* clear the interrupt */
     412    }
     413}
     414
     415
     416
     417/*
     418 *                              SECTION 1
     419 *                ROUTINES TO MANIPULATE THE CIRCULAR BUFFER
     420 */
    440421
    441422/****************************************************************************
     
    456437    if ( SciRcvBufCount == 0 )
    457438    {
    458         rtems_fatal_error_occurred(0xDEAD);     // check the count first!
    459     }
    460 
    461     rtems_interrupt_disable( level );           // disable interrupts
    462 
    463     ch = SciRcvBuffer[SciRcvBufGetIndex];       // get next byte
    464 
    465     SciRcvBufGetIndex++;                        // bump the index
    466 
    467     SciRcvBufGetIndex &= SCI_RCV_BUF_SIZE - 1;  // and wrap it
    468 
    469     SciRcvBufCount--;                           // decrement counter
    470 
    471     rtems_interrupt_enable( level );            // restore interrupts
    472 
    473     return ch;                                  // return the char
     439        rtems_fatal_error_occurred(0xDEAD);     /* check the count first! */
     440    }
     441
     442    rtems_interrupt_disable( level );           /* disable interrupts */
     443
     444    ch = SciRcvBuffer[SciRcvBufGetIndex];       /* get next byte */
     445
     446    SciRcvBufGetIndex++;                        /* bump the index */
     447
     448    SciRcvBufGetIndex &= SCI_RCV_BUF_SIZE - 1;  /* and wrap it */
     449
     450    SciRcvBufCount--;                           /* decrement counter */
     451
     452    rtems_interrupt_enable( level );            /* restore interrupts */
     453
     454    return ch;                                  /* return the char */
    474455}
    475456
     
    489470    rtems_interrupt_level level;
    490471
    491     if ( SciRcvBufCount == SCI_RCV_BUF_SIZE )   // is there room?
    492     {
    493         return;                                 // no, throw it away
    494     }
    495 
    496     rtems_interrupt_disable( level );           // disable interrupts
    497 
    498     SciRcvBuffer[SciRcvBufPutIndex] = ch;       // put it in the buf
    499 
    500     SciRcvBufPutIndex++;                        // bump the index
    501 
    502     SciRcvBufPutIndex &= SCI_RCV_BUF_SIZE - 1;  // and wrap it
    503 
    504     SciRcvBufCount++;                           // increment counter
    505 
    506     rtems_interrupt_enable( level );            // restore interrupts
    507 
    508     return;                                     // return
     472    if ( SciRcvBufCount == SCI_RCV_BUF_SIZE )   /* is there room? */
     473    {
     474        return;                                 /* no, throw it away */
     475    }
     476
     477    rtems_interrupt_disable( level );           /* disable interrupts */
     478
     479    SciRcvBuffer[SciRcvBufPutIndex] = ch;       /* put it in the buf */
     480
     481    SciRcvBufPutIndex++;                        /* bump the index */
     482
     483    SciRcvBufPutIndex &= SCI_RCV_BUF_SIZE - 1;  /* and wrap it */
     484
     485    SciRcvBufCount++;                           /* increment counter */
     486
     487    rtems_interrupt_enable( level );            /* restore interrupts */
     488
     489    return;                                     /* return */
    509490}
    510491
     
    520501****************************************************************************/
    521502
    522 #if 0                                           // prevents compiler warning
     503#if 0                                           /* prevents compiler warning */
    523504static void SciRcvBufFlush( void )
    524505{
    525506    rtems_interrupt_level level;
    526507
    527     rtems_interrupt_disable( level );           // disable interrupts
     508    rtems_interrupt_disable( level );           /* disable interrupts */
    528509
    529510    memset( SciRcvBuffer, 0, sizeof(SciRcvBuffer) );
    530511
    531     SciRcvBufPutIndex = 0;                      // clear
    532 
    533     SciRcvBufGetIndex = 0;                      // clear
    534 
    535     SciRcvBufCount = 0;                         // clear
    536 
    537     rtems_interrupt_enable( level );            // restore interrupts
    538 
    539     return;                                     // return
     512    SciRcvBufPutIndex = 0;                      /* clear */
     513
     514    SciRcvBufGetIndex = 0;                      /* clear */
     515
     516    SciRcvBufCount = 0;                         /* clear */
     517
     518    rtems_interrupt_enable( level );            /* restore interrupts */
     519
     520    return;                                     /* return */
    540521}
    541522#endif
     
    543524
    544525
    545 /////////////////////////////////////////////////////////////////////////////
    546 //
    547 //                              SECTION 2
    548 //            INTERRUPT BASED ENTRY POINTS FOR THE TERMIOS MODULE
    549 //
    550 /////////////////////////////////////////////////////////////////////////////
     526/*
     527 *
     528 *                              SECTION 2
     529 *            INTERRUPT BASED ENTRY POINTS FOR THE TERMIOS MODULE
     530 */
    551531
    552532/****************************************************************************
     
    564544****************************************************************************/
    565545
    566 int32_t   SciInterruptOpen(
    567     int32_t    major,
    568     int32_t    minor,
    569     void     *arg
     546int   SciInterruptOpen(
     547    int    major,
     548    int    minor,
     549    void  *arg
    570550)
    571551{
     
    573553    rtems_isr_entry old_vector;
    574554
    575     if ( minor != SCI_MINOR )                   // check minor device num
     555    if ( minor != SCI_MINOR )                   /* check minor device num */
    576556    {
    577557        return -1;
    578558    }
    579559
    580     if ( !args )                                // must have args
     560    if ( !args )                                /* must have args */
    581561    {
    582562        return -1;
    583563    }
    584564
    585     SciTermioTty = args->iop->data1;            // save address of struct
    586 
    587     SciDisableAllInterrupts();                  // turn off sci interrupts
    588 
    589     // THIS IS ACTUALLY A BAD THING - SETTING LINE PARAMETERS HERE
    590     // IT SHOULD BE DONE THROUGH TCSETATTR() WHEN THE CONSOLE IS OPENED!!!
    591 
    592 //  SciSetBaud(115200);                         // set the baud rate
    593 //  SciSetBaud( 57600);                         // set the baud rate
    594 //  SciSetBaud( 38400);                         // set the baud rate
    595 SciSetBaud( 19200);                         // set the baud rate
    596 //    SciSetBaud(  9600);                         // set the baud rate
    597 
    598     SciSetParity(SCI_PARITY_NONE);              // set parity to none
    599 
    600     SciSetDataBits(SCI_8_DATA_BITS);            // set data bits to 8
    601 
    602     // Install our interrupt handler into RTEMS, where does 66 come from?
     565    SciTermioTty = args->iop->data1;            /* save address of struct */
     566
     567    SciDisableAllInterrupts();                  /* turn off sci interrupts */
     568
     569    /* THIS IS ACTUALLY A BAD THING - SETTING LINE PARAMETERS HERE */
     570    /* IT SHOULD BE DONE THROUGH TCSETATTR() WHEN THE CONSOLE IS OPENED!!! */
     571
     572/*  SciSetBaud(115200);                         set the baud rate */
     573/*  SciSetBaud( 57600);                         set the baud rate */
     574/*  SciSetBaud( 38400);                         set the baud rate */
     575    SciSetBaud( 19200);                      /* set the baud rate */
     576/*  SciSetBaud(  9600);                         set the baud rate */
     577
     578    SciSetParity(SCI_PARITY_NONE);              /* set parity to none */
     579
     580    SciSetDataBits(SCI_8_DATA_BITS);            /* set data bits to 8 */
     581
     582    /* Install our interrupt handler into RTEMS, where does 66 come from? */
    603583
    604584    rtems_interrupt_catch( SciIsr, 66, &old_vector );
     
    608588    *QILR |= 0x06 & 0x07;
    609589
    610     SciEnableTransmitter();                     // enable the transmitter
    611 
    612     SciEnableReceiver();                        // enable the receiver
    613 
    614     SciEnableReceiveInterrupts();               // enable rcv interrupts
     590    SciEnableTransmitter();                     /* enable the transmitter */
     591
     592    SciEnableReceiver();                        /* enable the receiver */
     593
     594    SciEnableReceiveInterrupts();               /* enable rcv interrupts */
    615595
    616596    return RTEMS_SUCCESSFUL;
     
    630610****************************************************************************/
    631611
    632 int32_t   SciInterruptClose(
    633     int32_t    major,
    634     int32_t    minor,
    635     void     *arg
     612int   SciInterruptClose(
     613    int    major,
     614    int    minor,
     615    void  *arg
    636616)
    637617{
     
    654634****************************************************************************/
    655635
    656 int32_t   SciInterruptWrite(
    657     int32_t      minor,
     636int   SciInterruptWrite(
     637    int         minor,
    658638    const char *buf,
    659     int32_t      len
     639    int         len
    660640)
    661641{
    662     // We are using interrupt driven output so termios only sends us
    663     // one character at a time. The sci does not have a fifo.
    664 
    665     if ( !len )                                 // no data?
    666     {
    667         return 0;                               // return error
    668     }
    669 
    670     if ( minor != SCI_MINOR )                   // check the minor dev num
    671     {
    672         return 0;                               // return error
    673     }
    674 
    675     if ( SciOpened == DRIVER_OPENED )           // is the driver api open?
    676     {
    677         return 1;                               // yep, throw this away
    678     }
    679 
    680     SciWriteCharNoWait(*buf);                   // try to send a char
    681 
    682     *SCSR &= SCI_CLEAR_TDRE;                    // clear tx data reg empty flag
    683 
    684     SciEnableTransmitInterrupts();              // enable the tx interrupt
    685 
    686     return 1;                                   // return success
     642    /* We are using interrupt driven output so termios only sends us */
     643    /* one character at a time. The sci does not have a fifo. */
     644
     645    if ( !len )                                 /* no data? */
     646    {
     647        return 0;                               /* return error */
     648    }
     649
     650    if ( minor != SCI_MINOR )                   /* check the minor dev num */
     651    {
     652        return 0;                               /* return error */
     653    }
     654
     655    if ( SciOpened == DRIVER_OPENED )           /* is the driver api open? */
     656    {
     657        return 1;                               /* yep, throw this away */
     658    }
     659
     660    SciWriteCharNoWait(*buf);                   /* try to send a char */
     661
     662    *SCSR &= SCI_CLEAR_TDRE;                    /* clear tx data reg empty flag */
     663
     664    SciEnableTransmitInterrupts();              /* enable the tx interrupt */
     665
     666    return 1;                                   /* return success */
    687667}
    688668
     
    699679****************************************************************************/
    700680
    701 int32_t   SciSetAttributes(
    702     int32_t   minor,
     681int   SciSetAttributes(
     682    int                   minor,
    703683    const struct termios *t
    704684)
     
    709689    uint16_t    sci_databits = 0;
    710690
    711     if ( minor != SCI_MINOR )                   // check the minor dev num
    712     {
    713         return -1;                              // return error
    714     }
    715 
    716     // if you look closely you will see this is the only thing we use
    717     // set the baud rate
    718 
    719     baud_requested = t->c_cflag & CBAUD;        // baud rate
     691    if ( minor != SCI_MINOR )                   /* check the minor dev num */
     692    {
     693        return -1;                              /* return error */
     694    }
     695
     696    /* if you look closely you will see this is the only thing we use */
     697    /* set the baud rate */
     698
     699    baud_requested = t->c_cflag & CBAUD;        /* baud rate */
    720700
    721701    if (!baud_requested)
    722702    {
    723 //        baud_requested = B9600;                 // default to 9600 baud
    724         baud_requested = B19200;                 // default to 19200 baud
     703/*        baud_requested = B9600;                   default to 9600 baud */
     704        baud_requested = B19200;                 /* default to 19200 baud */
    725705    }
    726706
    727707    sci_rate = termios_baud_to_number( baud_requested );
    728708
    729     // parity error detection
    730 
    731     if (t->c_cflag & PARENB)                    // enable parity detection?
     709    /* parity error detection */
     710
     711    if (t->c_cflag & PARENB)                    /* enable parity detection? */
    732712    {
    733713        if (t->c_cflag & PARODD)
    734714        {
    735             sci_parity = SCI_PARITY_ODD;        // select odd parity
     715            sci_parity = SCI_PARITY_ODD;        /* select odd parity */
    736716        }
    737717        else
    738718        {
    739             sci_parity = SCI_PARITY_EVEN;       // select even parity
     719            sci_parity = SCI_PARITY_EVEN;       /* select even parity */
    740720        }
    741721    }
    742722    else
    743723    {
    744         sci_parity = SCI_PARITY_NONE;           // no parity, most common
    745     }
    746 
    747     //  set the number of data bits, 8 is most common
    748 
    749     if (t->c_cflag & CSIZE)                     // was it specified?
     724        sci_parity = SCI_PARITY_NONE;           /* no parity, most common */
     725    }
     726
     727    /*  set the number of data bits, 8 is most common */
     728
     729    if (t->c_cflag & CSIZE)                     /* was it specified? */
    750730    {
    751731        switch (t->c_cflag & CSIZE)
     
    757737    else
    758738    {
    759         sci_databits = SCI_8_DATA_BITS;         // default to 8 data bits
    760     }
    761 
    762     //  the number of stop bits; always 1 for SCI
     739        sci_databits = SCI_8_DATA_BITS;         /* default to 8 data bits */
     740    }
     741
     742    /*  the number of stop bits; always 1 for SCI */
    763743
    764744    if (t->c_cflag & CSTOPB)
    765745    {
    766         // do nothing
    767     }
    768 
    769     // setup the hardware with these serial port parameters
    770 
    771     SciSetBaud(sci_rate);                       // set the baud rate
    772 
    773     SciSetParity(sci_parity);                   // set the parity type
    774 
    775     SciSetDataBits(sci_databits);               // set the data bits
     746        /* do nothing */
     747    }
     748
     749    /* setup the hardware with these serial port parameters */
     750
     751    SciSetBaud(sci_rate);                       /* set the baud rate */
     752    SciSetParity(sci_parity);                   /* set the parity type */
     753    SciSetDataBits(sci_databits);               /* set the data bits */
    776754
    777755    return RTEMS_SUCCESSFUL;
     
    780758
    781759
    782 /////////////////////////////////////////////////////////////////////////////
    783 //
    784 //                              SECTION 3
    785 //            POLLING BASED ENTRY POINTS FOR THE TERMIOS MODULE
    786 //
    787 /////////////////////////////////////////////////////////////////////////////
     760/*
     761 *
     762 *                              SECTION 3
     763 *            POLLING BASED ENTRY POINTS FOR THE TERMIOS MODULE
     764 */
    788765
    789766/****************************************************************************
     
    799776****************************************************************************/
    800777
    801 int32_t   SciPolledOpen(
    802     int32_t   major,
    803     int32_t   minor,
    804     void    *arg
     778int   SciPolledOpen(
     779    int   major,
     780    int   minor,
     781    void *arg
    805782)
    806783{
    807784    rtems_libio_open_close_args_t * args = arg;
    808785
    809     if ( minor != SCI_MINOR )                   // check minor device num
     786    if ( minor != SCI_MINOR )                   /* check minor device num */
    810787    {
    811788        return -1;
    812789    }
    813790
    814     if ( !args )                                // must have args
     791    if ( !args )                                /* must have args */
    815792    {
    816793        return -1;
    817794    }
    818795
    819     SciTermioTty = args->iop->data1;            // Store tty pointer
    820 
    821     SciDisableAllInterrupts();                  // don't generate interrupts
    822 
    823     // THIS IS ACTUALLY A BAD THING - SETTING LINE PARAMETERS HERE
    824     // IT SHOULD BE DONE THROUGH TCSETATTR() WHEN THE CONSOLE IS OPENED!!!
    825 
    826 //  SciSetBaud(115200);                         // set the baud rate
    827 //  SciSetBaud( 57600);                         // set the baud rate
    828 //  SciSetBaud( 38400);                         // set the baud rate
    829   SciSetBaud( 19200);                         // set the baud rate
    830 //  SciSetBaud(  9600);                         // set the baud rate
    831 
    832     SciSetParity(SCI_PARITY_NONE);              // set no parity
    833 
    834     SciSetDataBits(SCI_8_DATA_BITS);            // set 8 data bits
    835 
    836     SciEnableTransmitter();                     // enable the xmitter
    837 
    838     SciEnableReceiver();                        // enable the rcvr
     796    SciTermioTty = args->iop->data1;            /* Store tty pointer */
     797
     798    SciDisableAllInterrupts();                  /* don't generate interrupts */
     799
     800    /* THIS IS ACTUALLY A BAD THING - SETTING LINE PARAMETERS HERE */
     801    /* IT SHOULD BE DONE THROUGH TCSETATTR() WHEN THE CONSOLE IS OPENED!!! */
     802
     803/*  SciSetBaud(115200);                            set the baud rate */
     804/*  SciSetBaud( 57600);                            set the baud rate */
     805/*  SciSetBaud( 38400);                            set the baud rate */
     806  SciSetBaud( 19200);                         /* set the baud rate */
     807/*  SciSetBaud(  9600);                            set the baud rate */
     808
     809    SciSetParity(SCI_PARITY_NONE);              /* set no parity */
     810
     811    SciSetDataBits(SCI_8_DATA_BITS);            /* set 8 data bits */
     812
     813    SciEnableTransmitter();                     /* enable the xmitter */
     814
     815    SciEnableReceiver();                        /* enable the rcvr */
    839816
    840817    return RTEMS_SUCCESSFUL;
     
    854831****************************************************************************/
    855832
    856 int32_t   SciPolledClose(
    857     int32_t    major,
    858     int32_t    minor,
    859     void     *arg
     833int   SciPolledClose(
     834    int    major,
     835    int    minor,
     836    void  *arg
    860837)
    861838{
     
    876853****************************************************************************/
    877854
    878 int32_t   SciPolledRead(
    879     int32_t   minor
     855int   SciPolledRead(
     856    int   minor
    880857)
    881858{
    882     if ( minor != SCI_MINOR )               // check the minor dev num
    883     {
    884         return -1;                          // return error
    885     }
    886 
    887     if ( SciCharAvailable() )               // if a char is available
    888     {
    889         return SciReadCharNoWait();         // read the rx data register
    890     }
    891 
    892     return -1;                              // return error
     859    if ( minor != SCI_MINOR )               /* check the type-punned dev num */
     860    {
     861        return -1;                          /* return error */
     862    }
     863
     864    if ( SciCharAvailable() )               /* if a char is available */
     865    {
     866        return SciReadCharNoWait();         /* read the rx data register */
     867    }
     868
     869    return -1;                              /* return error */
    893870}
    894871
     
    907884****************************************************************************/
    908885
    909 int32_t   SciPolledWrite(
    910     int32_t        minor,
    911     const char   *buf,
    912     int32_t        len
     886int   SciPolledWrite(
     887    int         minor,
     888    const char *buf,
     889    int         len
    913890)
    914891{
    915892    int32_t   written = 0;
    916893
    917     if ( minor != SCI_MINOR )                   // check minor device num
     894    if ( minor != SCI_MINOR )                   /* check minor device num */
    918895    {
    919896        return -1;
    920897    }
    921898
    922     if ( SciOpened == DRIVER_OPENED )           // is the driver api open?
    923     {
    924         return -1;                              // toss the data
    925     }
    926 
    927     // send each byte in the string out the port
     899    if ( SciOpened == DRIVER_OPENED )           /* is the driver api open? */
     900    {
     901        return -1;                              /* toss the data */
     902    }
     903
     904    /* send each byte in the string out the port */
    928905
    929906    while ( written < len )
    930907    {
    931         SciWriteCharWait(*buf++);               // send a byte
    932 
    933         written++;                              // increment counter
    934     }
    935 
    936     return written;                             // return count
    937 }
    938 
    939 
    940 
    941 /////////////////////////////////////////////////////////////////////////////
    942 //
    943 //                              SECTION 4
    944 //                 DEVICE DRIVER PUBLIC API ENTRY POINTS
    945 //
    946 /////////////////////////////////////////////////////////////////////////////
     908        SciWriteCharWait(*buf++);               /* send a byte */
     909
     910        written++;                              /* increment counter */
     911    }
     912
     913    return written;                             /* return count */
     914}
     915
     916
     917
     918/*
     919 *
     920 *                              SECTION 4
     921 *                 DEVICE DRIVER PUBLIC API ENTRY POINTS
     922 */
    947923
    948924/****************************************************************************
     
    963939)
    964940{
    965 //     rtems_status_code status;
    966 
    967 //printk("%s\r\n", __FUNCTION__);
    968 
    969     // register the SCI device name for termios console i/o
    970     // this is done over in console.c which doesn't seem exactly right
    971     // but there were problems doing it here...
    972 
    973 //  status = rtems_io_register_name( "/dev/sci", major, 0 );
    974 
    975 //  if (status != RTEMS_SUCCESSFUL)
    976 //      rtems_fatal_error_occurred(status);
    977 
    978     SciMajor = major;                           // save the rtems major number
    979 
    980     SciOpened = DRIVER_CLOSED;                  // initial state is closed
    981 
    982     // if you have an interrupt handler, install it here
    983 
    984     SciInited = 1;                              // set the inited flag
     941/*     rtems_status_code status; */
     942
     943/*printk("%s\r\n", __FUNCTION__); */
     944
     945    /* register the SCI device name for termios console i/o
     946     * this is done over in console.c which doesn't seem exactly right
     947     * but there were problems doing it here...
     948     */
     949
     950/*  status = rtems_io_register_name( "/dev/sci", major, 0 ); */
     951
     952/*  if (status != RTEMS_SUCCESSFUL) */
     953/*      rtems_fatal_error_occurred(status); */
     954
     955    SciMajor = major;                           /* save the rtems major number */
     956
     957    SciOpened = DRIVER_CLOSED;                  /* initial state is closed */
     958
     959    /* if you have an interrupt handler, install it here */
     960
     961    SciInited = 1;                              /* set the inited flag */
    985962
    986963    return RTEMS_SUCCESSFUL;
     
    1009986)
    1010987{
    1011 //printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor);
    1012 
    1013     if (SciInited == 0)                         // must be initialized first!
     988/*printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor); */
     989
     990    if (SciInited == 0)                         /* must be initialized first! */
    1014991    {
    1015992        return RTEMS_NOT_CONFIGURED;
     
    1018995    if (minor != SCI_MINOR)
    1019996    {
    1020         return RTEMS_INVALID_NAME;              // verify minor number
     997        return RTEMS_INVALID_NAME;              /* verify minor number */
    1021998    }
    1022999
    10231000    if (SciOpened == DRIVER_OPENED)
    10241001    {
    1025         return RTEMS_RESOURCE_IN_USE;           // already opened!
    1026     }
    1027 
    1028     SciOpened = DRIVER_OPENED;                  // set the opened flag
     1002        return RTEMS_RESOURCE_IN_USE;           /* already opened! */
     1003    }
     1004
     1005    SciOpened = DRIVER_OPENED;                  /* set the opened flag */
    10291006
    10301007    return RTEMS_SUCCESSFUL;
     
    10521029)
    10531030{
    1054 //printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor);
     1031/*printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor); */
    10551032
    10561033    if (minor != SCI_MINOR)
    10571034    {
    1058         return RTEMS_INVALID_NAME;              // check the minor number
     1035        return RTEMS_INVALID_NAME;              /* check the minor number */
    10591036    }
    10601037
    10611038    if (SciOpened != DRIVER_OPENED)
    10621039    {
    1063         return RTEMS_INCORRECT_STATE;           // must be opened first
    1064     }
    1065 
    1066     SciOpened = DRIVER_CLOSED;                  // set the flag
     1040        return RTEMS_INCORRECT_STATE;           /* must be opened first */
     1041    }
     1042
     1043    SciOpened = DRIVER_CLOSED;                  /* set the flag */
    10671044
    10681045    return RTEMS_SUCCESSFUL;
     
    10891066)
    10901067{
    1091     rtems_libio_rw_args_t *rw_args;             // ptr to argument struct
    1092     uint8_t   *buffer;
     1068    rtems_libio_rw_args_t *rw_args;             /* ptr to argument struct */
     1069    char      *buffer;
    10931070    uint16_t   length;
    10941071
    1095     rw_args = (rtems_libio_rw_args_t *) arg;    // arguments to read()
     1072    rw_args = (rtems_libio_rw_args_t *) arg;    /* arguments to read() */
    10961073
    10971074    if (minor != SCI_MINOR)
    10981075    {
    1099         return RTEMS_INVALID_NAME;              // check the minor number
     1076        return RTEMS_INVALID_NAME;              /* check the minor number */
    11001077    }
    11011078
    11021079    if (SciOpened == DRIVER_CLOSED)
    11031080    {
    1104         return RTEMS_INCORRECT_STATE;           // must be opened first
    1105     }
    1106 
    1107     buffer = rw_args->buffer;                   // points to user's buffer
    1108 
    1109     length = rw_args->count;                    // how many bytes they want
    1110 
    1111 //  *buffer = SciReadCharWait();                // wait for a character
    1112 
    1113     // if there isn't a character available, wait until one shows up
    1114     // or the timeout period expires, which ever happens first
    1115 
    1116     if ( SciRcvBufCount == 0 )                  // no chars
    1117     {
    1118         // wait for someone to wake me up...
    1119         //rtems_task_wake_after(SciReadTimeout);
    1120     }
    1121 
    1122     if ( SciRcvBufCount )                       // any characters locally?
    1123     {
    1124         *buffer = SciRcvBufGetChar();           // get the character
    1125 
    1126         rw_args->bytes_moved = 1;               // how many we actually read
     1081        return RTEMS_INCORRECT_STATE;           /* must be opened first */
     1082    }
     1083
     1084    buffer = rw_args->buffer;                   /* points to user's buffer */
     1085
     1086    length = rw_args->count;                    /* how many bytes they want */
     1087
     1088/*  *buffer = SciReadCharWait();                   wait for a character */
     1089
     1090    /* if there isn't a character available, wait until one shows up */
     1091    /* or the timeout period expires, which ever happens first */
     1092
     1093    if ( SciRcvBufCount == 0 )                  /* no chars */
     1094    {
     1095        /* wait for someone to wake me up... */
     1096        /*rtems_task_wake_after(SciReadTimeout); */
     1097    }
     1098
     1099    if ( SciRcvBufCount )                       /* any characters locally? */
     1100    {
     1101        *buffer = SciRcvBufGetChar();           /* get the character */
     1102
     1103        rw_args->bytes_moved = 1;               /* how many we actually read */
    11271104    }
    11281105
     
    11501127)
    11511128{
    1152     rtems_libio_rw_args_t *rw_args;             // ptr to argument struct
     1129    rtems_libio_rw_args_t *rw_args;             /* ptr to argument struct */
    11531130    uint8_t   *buffer;
    11541131    uint16_t   length;
     
    11581135    if (minor != SCI_MINOR)
    11591136    {
    1160         return RTEMS_INVALID_NAME;              // check the minor number
     1137        return RTEMS_INVALID_NAME;              /* check the minor number */
    11611138    }
    11621139
    11631140    if (SciOpened == DRIVER_CLOSED)
    11641141    {
    1165         return RTEMS_INCORRECT_STATE;           // must be opened first
    1166     }
    1167 
    1168     buffer = (uint8_t*)rw_args->buffer;       // points to data
    1169 
    1170     length = rw_args->count;                    // how many bytes
     1142        return RTEMS_INCORRECT_STATE;           /* must be opened first */
     1143    }
     1144
     1145    buffer = (uint8_t*)rw_args->buffer;       /* points to data */
     1146
     1147    length = rw_args->count;                    /* how many bytes */
    11711148
    11721149    while (length--)
    11731150    {
    1174         SciWriteCharWait(*buffer++);            // send the bytes out
    1175     }
    1176 
    1177     rw_args->bytes_moved = rw_args->count;      // how many we wrote
     1151        SciWriteCharWait(*buffer++);            /* send the bytes out */
     1152    }
     1153
     1154    rw_args->bytes_moved = rw_args->count;      /* how many we wrote */
    11781155
    11791156    return RTEMS_SUCCESSFUL;
     
    12001177)
    12011178{
    1202     rtems_libio_ioctl_args_t *args = arg;       // rtems arg struct
    1203     uint16_t   command;                         // the cmd to execute
    1204     uint16_t   unused;                          // maybe later
    1205     uint16_t   *ptr;                            // ptr to user data
    1206 
    1207 //printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor);
    1208 
    1209     // do some sanity checking
     1179    rtems_libio_ioctl_args_t *args = arg;       /* rtems arg struct */
     1180    uint16_t   command;                         /* the cmd to execute */
     1181    uint16_t   unused;                          /* maybe later */
     1182    uint16_t   *ptr;                            /* ptr to user data */
     1183
     1184/*printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor); */
     1185
     1186    /* do some sanity checking */
    12101187
    12111188    if (minor != SCI_MINOR)
    12121189    {
    1213         return RTEMS_INVALID_NAME;              // check the minor number
     1190        return RTEMS_INVALID_NAME;              /* check the minor number */
    12141191    }
    12151192
    12161193    if (SciOpened == DRIVER_CLOSED)
    12171194    {
    1218         return RTEMS_INCORRECT_STATE;           // must be open first
     1195        return RTEMS_INCORRECT_STATE;           /* must be open first */
    12191196    }
    12201197
    12211198    if (args == 0)
    12221199    {
    1223         return RTEMS_INVALID_ADDRESS;           // must have args
    1224     }
    1225 
    1226     args->ioctl_return = -1;                    // assume an error
    1227 
    1228     command = args->command;                    // get the command
    1229     ptr     = args->buffer;                     // this is an address
    1230     unused  = *ptr;                             // brightness
    1231 
    1232     if (command == SCI_SEND_BREAK)              // process the command
    1233     {
    1234         SciSendBreak();                         // send break char
    1235     }
    1236 
    1237     args->ioctl_return = 0;                     // return status
     1200        return RTEMS_INVALID_ADDRESS;           /* must have args */
     1201    }
     1202
     1203    args->ioctl_return = -1;                    /* assume an error */
     1204
     1205    command = args->command;                    /* get the command */
     1206    ptr     = args->buffer;                     /* this is an address */
     1207    unused  = *ptr;                             /* brightness */
     1208
     1209    if (command == SCI_SEND_BREAK)              /* process the command */
     1210    {
     1211        SciSendBreak();                         /* send break char */
     1212    }
     1213
     1214    args->ioctl_return = 0;                     /* return status */
    12381215
    12391216    return RTEMS_SUCCESSFUL;
     
    12421219
    12431220
    1244 /////////////////////////////////////////////////////////////////////////////
    1245 //
    1246 //                              SECTION 5
    1247 //                       HARDWARE LEVEL ROUTINES
    1248 //
    1249 /////////////////////////////////////////////////////////////////////////////
     1221/*
     1222 *
     1223 *                              SECTION 5
     1224 *                       HARDWARE LEVEL ROUTINES
     1225 */
    12501226
    12511227/****************************************************************************
     
    12631239    uint16_t   save_sccr1;
    12641240
    1265 // when you open the console you need to set the termio struct baud rate
    1266 // it has a default value of 9600, when someone calls tcsetattr it reverts!
    1267 
    1268     SciBaud = rate;                             // save the rate
    1269 
    1270     // calculate the register value as a float and convert to an int
    1271     // set baud rate - you must define the system clock constant
    1272     // see mrm332.h for an example
     1241/* when you open the console you need to set the termio struct baud rate */
     1242/* it has a default value of 9600, when someone calls tcsetattr it reverts! */
     1243
     1244    SciBaud = rate;                             /* save the rate */
     1245
     1246    /* calculate the register value as a float and convert to an int */
     1247    /* set baud rate - you must define the system clock constant */
     1248    /* see mrm332.h for an example */
    12731249
    12741250    value = ( (uint16_t) ( SYS_CLOCK / rate / 32.0 + 0.5 ) & 0x1fff );
    12751251
    1276     save_sccr1 = *SCCR1;                        // save register
    1277 
    1278     // also turns off the xmtr and rcvr
    1279 
    1280     *SCCR1 &= SCI_DISABLE_INT_ALL;              // disable interrupts
    1281 
    1282     *SCCR0 = value;                             // write the register
    1283 
    1284     *SCCR1 = save_sccr1;                        // restore register
     1252    save_sccr1 = *SCCR1;                        /* save register */
     1253
     1254    /* also turns off the xmtr and rcvr */
     1255
     1256    *SCCR1 &= SCI_DISABLE_INT_ALL;              /* disable interrupts */
     1257
     1258    *SCCR0 = value;                             /* write the register */
     1259
     1260    *SCCR1 = save_sccr1;                        /* restore register */
    12851261
    12861262    return;
     
    13021278    uint16_t   value;
    13031279
    1304     value = *SCCR1;                             // get the register
     1280    value = *SCCR1;                             /* get the register */
    13051281
    13061282    if (parity == SCI_PARITY_ODD)
    13071283    {
    1308         value |= SCI_PARITY_ENABLE;             // parity enabled
    1309         value |= SCI_PARITY_ODD;                // parity odd
     1284        value |= SCI_PARITY_ENABLE;             /* parity enabled */
     1285        value |= SCI_PARITY_ODD;                /* parity odd */
    13101286    }
    13111287
    13121288    else if (parity == SCI_PARITY_EVEN)
    13131289    {
    1314         value |= SCI_PARITY_ENABLE;             // parity enabled
    1315         value &= ~SCI_PARITY_ODD;               // parity even
     1290        value |= SCI_PARITY_ENABLE;             /* parity enabled */
     1291        value &= ~SCI_PARITY_ODD;               /* parity even */
    13161292    }
    13171293
    13181294    else if (parity == SCI_PARITY_NONE)
    13191295    {
    1320         value &= ~SCI_PARITY_ENABLE;            // disabled, most common
     1296        value &= ~SCI_PARITY_ENABLE;            /* disabled, most common */
    13211297    }
    13221298
    13231299    /* else no changes */
    13241300
    1325     *SCCR1 = value;                             // write the register
     1301    *SCCR1 = value;                             /* write the register */
    13261302
    13271303    return;
     
    13431319    uint16_t   value;
    13441320
    1345     value = *SCCR1;                             // get the register
     1321    value = *SCCR1;                             /* get the register */
    13461322
    13471323    /* note - the parity setting affects the number of data bits */
     
    13491325    if (bits == SCI_9_DATA_BITS)
    13501326    {
    1351         value |= SCI_9_DATA_BITS;               // 9 data bits
     1327        value |= SCI_9_DATA_BITS;               /* 9 data bits */
    13521328    }
    13531329
    13541330    else if (bits == SCI_8_DATA_BITS)
    13551331    {
    1356         value &= SCI_8_DATA_BITS;               // 8 data bits
     1332        value &= SCI_8_DATA_BITS;               /* 8 data bits */
    13571333    }
    13581334
    13591335    /* else no changes */
    13601336
    1361     *SCCR1 = value;                             // write the register
     1337    *SCCR1 = value;                             /* write the register */
    13621338
    13631339    return;
     
    13791355static void inline SciDisableAllInterrupts( void )
    13801356{
    1381     // this also turns off the xmtr and rcvr
     1357    /* this also turns off the xmtr and rcvr */
    13821358
    13831359    *SCCR1 &= SCI_DISABLE_INT_ALL;
     
    14491425void SciWriteCharWait(uint8_t   c)
    14501426{
    1451     // poll the fifo, waiting for room for another character
     1427    /* poll the fifo, waiting for room for another character */
    14521428
    14531429    while ( ( *SCSR & SCI_XMTR_AVAILABLE ) == 0 )
     
    14631439    }
    14641440
    1465     *SCDR = c;                                  // send the charcter
    1466 
    1467     SciBytesOut++;                              // increment the counter
     1441    *SCDR = c;                                  /* send the charcter */
     1442
     1443    SciBytesOut++;                              /* increment the counter */
    14681444
    14691445    return;
     
    14831459    if ( ( *SCSR & SCI_XMTR_AVAILABLE ) == 0 )
    14841460    {
    1485         return;                                 // no room, throw it away
    1486     }
    1487 
    1488     *SCDR = c;                                  // put the char in the fifo
    1489 
    1490     SciBytesOut++;                              // increment the counter
     1461        return;                                 /* no room, throw it away */
     1462    }
     1463
     1464    *SCDR = c;                                  /* put the char in the fifo */
     1465
     1466    SciBytesOut++;                              /* increment the counter */
    14911467
    14921468    return;
     
    15081484    uint8_t   ch;
    15091485
    1510     while ( SciCharAvailable() == 0 )           // anything there?
     1486    while ( SciCharAvailable() == 0 )           /* anything there? */
    15111487    {
    15121488      /* relinquish processor while waiting */
     
    15141490    }
    15151491
    1516     // if you have rcv ints enabled, then the isr will probably
    1517     // get the character before you will unless you turn off ints
    1518     // ie polling and ints don't mix that well
    1519 
    1520     ch = *SCDR;                                 // get the charcter
    1521 
    1522     SciBytesIn++;                               // increment the counter
    1523 
    1524     return ch;                                  // return the char
     1492    /* if you have rcv ints enabled, then the isr will probably */
     1493    /* get the character before you will unless you turn off ints */
     1494    /* ie polling and ints don't mix that well */
     1495
     1496    ch = *SCDR;                                 /* get the charcter */
     1497
     1498    SciBytesIn++;                               /* increment the counter */
     1499
     1500    return ch;                                  /* return the char */
    15251501}
    15261502
     
    15381514    uint8_t   ch;
    15391515
    1540     if ( SciCharAvailable() == 0 )              // anything there?
     1516    if ( SciCharAvailable() == 0 )              /* anything there? */
    15411517        return -1;
    15421518
    1543     ch = *SCDR;                                 // get the character
    1544 
    1545     SciBytesIn++;                               // increment the count
    1546 
    1547     return ch;                                  // return the char
     1519    ch = *SCDR;                                 /* get the character */
     1520
     1521    SciBytesIn++;                               /* increment the count */
     1522
     1523    return ch;                                  /* return the char */
    15481524}
    15491525
     
    15611537uint8_t   inline SciCharAvailable( void )
    15621538{
    1563     return ( *SCSR & SCI_RCVR_READY );          // char in data register?
     1539    return ( *SCSR & SCI_RCVR_READY );          /* char in data register? */
    15641540}
    15651541
     
    15771553void SciSendBreak( void )
    15781554{
    1579     // From the Motorola QSM reference manual -
    1580 
    1581     // "if SBK is toggled by writing it first to a one and then immediately
    1582     // to a zero (in less than one serial frame interval), the transmitter
    1583     // sends only one or two break frames before reverting to mark (idle)
    1584     // or before commencing to send more data"
    1585 
    1586     *SCCR1 |=  SCI_SEND_BREAK;                  // set the bit
    1587 
    1588     *SCCR1 &= ~SCI_SEND_BREAK;                  // clear the bit
     1555    /* From the Motorola QSM reference manual - */
     1556
     1557    /* "if SBK is toggled by writing it first to a one and then immediately */
     1558    /* to a zero (in less than one serial frame interval), the transmitter */
     1559    /* sends only one or two break frames before reverting to mark (idle) */
     1560    /* or before commencing to send more data" */
     1561
     1562    *SCCR1 |=  SCI_SEND_BREAK;                  /* set the bit */
     1563
     1564    *SCCR1 &= ~SCI_SEND_BREAK;                  /* clear the bit */
    15891565
    15901566    return;
     
    15931569
    15941570
    1595 /////////////////////////////////////////////////////////////////////////////
    1596 //
    1597 //                             SECTION 6
    1598 //                             TEST CODE
    1599 //
    1600 /////////////////////////////////////////////////////////////////////////////
     1571/*
     1572 *
     1573 *                             SECTION 6
     1574 *                             TEST CODE
     1575 */
    16011576
    16021577/****************************************************************************
     
    16091584
    16101585#if 0
    1611 #define O_RDWR LIBIO_FLAGS_READ_WRITE           // dont like this but...
     1586#define O_RDWR LIBIO_FLAGS_READ_WRITE           /* dont like this but... */
    16121587
    16131588void SciUnitTest()
    16141589{
    1615     uint8_t   byte;                             // a character
    1616     uint16_t   fd;                              // file descriptor for device
    1617     uint16_t   result;                          // result of ioctl
    1618 
    1619     fd = open("/dev/sci",O_RDWR);               // open the device
     1590    uint8_t   byte;                             /* a character */
     1591    uint16_t   fd;                              /* file descriptor for device */
     1592    uint16_t   result;                          /* result of ioctl */
     1593
     1594    fd = open("/dev/sci",O_RDWR);               /* open the device */
    16201595
    16211596printk("SCI open fd=%d\r\n",fd);
    16221597
    1623     result = write(fd, "abcd\r\n", 6);          // send a string
     1598    result = write(fd, "abcd\r\n", 6);          /* send a string */
    16241599
    16251600printk("SCI write result=%d\r\n",result);
    16261601
    1627     result = read(fd, &byte, 1);                // read a byte
     1602    result = read(fd, &byte, 1);                /* read a byte */
    16281603
    16291604printk("SCI read result=%d,byte=%x\r\n",result,byte);
  • c/src/lib/libbsp/m68k/mrm332/console/sci.h

    r1883c87 rda2fc6c0  
    1717*******************************************************************************/
    1818
    19 #define SCI_IOCTL_PARITY_NONE           0x00    // no parity bit after the data bits
    20 #define SCI_IOCTL_PARITY_ODD            0x01    // parity bit added after data bits
    21 #define SCI_IOCTL_PARITY_EVEN           0x02    // parity bit added after data bits
    22 #define SCI_IOCTL_PARITY_MARK           0x03    // parity bit is lo, -12 volts, logical 1
    23 #define SCI_IOCTL_PARITY_SPACE          0x04    // parity bit is hi, +12 volts, logical 0
    24 #define SCI_IOCTL_PARITY_FORCED_ON      0x03    // parity bit is forced hi or lo
    25 #define SCI_IOCTL_PARITY_FORCED_OFF     0x04    // parity bit is forced hi or lo
    26 
    27 #define SCI_IOCTL_BAUD_RATE             0x20    // set the baud rate, arg is baud
    28 
    29 #define SCI_IOCTL_DATA_BITS             0x30    // set the data bits, arg is # bits
    30 
    31 #define SCI_IOCTL_STOP_BITS_1           0x40    // 1 stop bit after char frame
    32 #define SCI_IOCTL_STOP_BITS_2           0x41    // 2 stop bit after char frame
    33 
    34 #define SCI_IOCTL_MODE_NORMAL           0x50    // normal operating mode
    35 #define SCI_IOCTL_MODE_LOOP             0x51    // internal loopback mode
    36 
    37 #define SCI_IOCTL_FLOW_NONE             0x60    // no flow control
    38 #define SCI_IOCTL_FLOW_RTS_CTS          0x61    // hardware flow control
    39 
    40 #define SCI_IOCTL_SEND_BREAK            0x70    // send an rs-232 break
    41 
    42 #define SCI_IOCTL_MODE_1200             0x80    // 1200,n,8,1 download mode
    43 #define SCI_IOCTL_MODE_9600             0x81    // 9600,n,8,1 download mode
    44 #define SCI_IOCTL_MODE_9_BIT            0x82    // 9600,forced,8,1 command mode
     19#define SCI_IOCTL_PARITY_NONE           0x00    /* no parity bit after the data bits */
     20#define SCI_IOCTL_PARITY_ODD            0x01    /* parity bit added after data bits */
     21#define SCI_IOCTL_PARITY_EVEN           0x02    /* parity bit added after data bits */
     22#define SCI_IOCTL_PARITY_MARK           0x03    /* parity bit is lo, -12 volts, logical 1 */
     23#define SCI_IOCTL_PARITY_SPACE          0x04    /* parity bit is hi, +12 volts, logical 0 */
     24#define SCI_IOCTL_PARITY_FORCED_ON      0x03    /* parity bit is forced hi or lo */
     25#define SCI_IOCTL_PARITY_FORCED_OFF     0x04    /* parity bit is forced hi or lo */
     26
     27#define SCI_IOCTL_BAUD_RATE             0x20    /* set the baud rate, arg is baud */
     28
     29#define SCI_IOCTL_DATA_BITS             0x30    /* set the data bits, arg is # bits */
     30
     31#define SCI_IOCTL_STOP_BITS_1           0x40    /* 1 stop bit after char frame */
     32#define SCI_IOCTL_STOP_BITS_2           0x41    /* 2 stop bit after char frame */
     33
     34#define SCI_IOCTL_MODE_NORMAL           0x50    /* normal operating mode */
     35#define SCI_IOCTL_MODE_LOOP             0x51    /* internal loopback mode */
     36
     37#define SCI_IOCTL_FLOW_NONE             0x60    /* no flow control */
     38#define SCI_IOCTL_FLOW_RTS_CTS          0x61    /* hardware flow control */
     39
     40#define SCI_IOCTL_SEND_BREAK            0x70    /* send an rs-232 break */
     41
     42#define SCI_IOCTL_MODE_1200             0x80    /* 1200,n,8,1 download mode */
     43#define SCI_IOCTL_MODE_9600             0x81    /* 9600,n,8,1 download mode */
     44#define SCI_IOCTL_MODE_9_BIT            0x82    /* 9600,forced,8,1 command mode */
    4545
    4646
     
    5050*******************************************************************************/
    5151
    52 // SCI Control Register 0  (SCCR0)  $FFFC08
    53 
    54 //  8 4 2 1 - 8 4 2 1 - 8 4 2 1 - 8 4 2 1
    55 //  ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^
    56 //  | | | |   | | | |   | | | |   | | | |
    57 //  | | | |   | | | |   | | | |   | | | +-----   0 baud rate divisor
    58 //  | | | |   | | | |   | | | |   | | +-------   1 baud rate divisor
    59 //  | | | |   | | | |   | | | |   | +---------   2 baud rate divisor
    60 //  | | | |   | | | |   | | | |   +-----------   3 baud rate divisor
    61 //  | | | |   | | | |   | | | |
    62 //  | | | |   | | | |   | | | +---------------   4 baud rate divisor
    63 //  | | | |   | | | |   | | +-----------------   5 baud rate divisor
    64 //  | | | |   | | | |   | +-------------------   6 baud rate divisor
    65 //  | | | |   | | | |   +---------------------   7 baud rate divisor
    66 //  | | | |   | | | |
    67 //  | | | |   | | | +-------------------------   8 baud rate divisor
    68 //  | | | |   | | +---------------------------   9 baud rate divisor
    69 //  | | | |   | +-----------------------------  10 baud rate divisor
    70 //  | | | |   +-------------------------------  11 baud rate divisor
    71 //  | | | |
    72 //  | | | +-----------------------------------  12 baud rate divisor
    73 //  | | +-------------------------------------  13 unused
    74 //  | +---------------------------------------  14 unused
    75 //  +-----------------------------------------  15 unused
    76 
    77 //  0 0 0 0 - 0 0 0 0 - 0 0 0 0 - 0 1 0 0       reset value - (64k baud?)
     52/* SCI Control Register 0  (SCCR0)  $FFFC08
     53
     54    8 4 2 1 - 8 4 2 1 - 8 4 2 1 - 8 4 2 1
     55    ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^
     56    | | | |   | | | |   | | | |   | | | |
     57    | | | |   | | | |   | | | |   | | | +-----   0 baud rate divisor
     58    | | | |   | | | |   | | | |   | | +-------   1 baud rate divisor
     59    | | | |   | | | |   | | | |   | +---------   2 baud rate divisor
     60    | | | |   | | | |   | | | |   +-----------   3 baud rate divisor
     61    | | | |   | | | |   | | | |
     62    | | | |   | | | |   | | | +---------------   4 baud rate divisor
     63    | | | |   | | | |   | | +-----------------   5 baud rate divisor
     64    | | | |   | | | |   | +-------------------   6 baud rate divisor
     65    | | | |   | | | |   +---------------------   7 baud rate divisor
     66    | | | |   | | | |
     67    | | | |   | | | +-------------------------   8 baud rate divisor
     68    | | | |   | | +---------------------------   9 baud rate divisor
     69    | | | |   | +-----------------------------  10 baud rate divisor
     70    | | | |   +-------------------------------  11 baud rate divisor
     71    | | | |
     72    | | | +-----------------------------------  12 baud rate divisor
     73    | | +-------------------------------------  13 unused
     74    | +---------------------------------------  14 unused
     75    +-----------------------------------------  15 unused
     76
     77    0 0 0 0 - 0 0 0 0 - 0 0 0 0 - 0 1 0 0       reset value - (64k baud?)
     78 */
    7879
    7980#define SCI_BAUD_57_6K            9
     
    8788
    8889
    89 //  SCI Control Register 1  (SCCR1)  $FFFC0A
    90 
    91 //  8 4 2 1 - 8 4 2 1 - 8 4 2 1 - 8 4 2 1
    92 //  ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^
    93 //  | | | |   | | | |   | | | |   | | | |
    94 //  | | | |   | | | |   | | | |   | | | +-----   0 send a break
    95 //  | | | |   | | | |   | | | |   | | +-------   1 rcvr wakeup mode
    96 //  | | | |   | | | |   | | | |   | +---------   2 rcvr enable
    97 //  | | | |   | | | |   | | | |   +-----------   3 xmtr enable
    98 //  | | | |   | | | |   | | | |
    99 //  | | | |   | | | |   | | | +---------------   4 idle line intr enable
    100 //  | | | |   | | | |   | | +-----------------   5 rcvr intr enable
    101 //  | | | |   | | | |   | +-------------------   6 xmit complete intr enable
    102 //  | | | |   | | | |   +---------------------   7 xmtr intr enable
    103 //  | | | |   | | | |
    104 //  | | | |   | | | +-------------------------   8 wakeup on address mark
    105 //  | | | |   | | +---------------------------   9 mode 1=9 bits, 0=8 bits
    106 //  | | | |   | +-----------------------------  10 parity enable 1=on, 0=off
    107 //  | | | |   +-------------------------------  11 parity type 1=odd, 0=even
    108 //  | | | |
    109 //  | | | +-----------------------------------  12 idle line select
    110 //  | | +-------------------------------------  13 wired-or mode
    111 //  | +---------------------------------------  14 loop mode
    112 //  +-----------------------------------------  15 unused
    113 
    114 //  0 0 0 0 - 0 0 0 0 - 0 0 0 0 - 0 0 0 0       reset value
    115 
    116 #define SCI_SEND_BREAK          0x0001          // 0000-0000-0000-0001
    117 #define SCI_RCVR_WAKEUP         0x0002          // 0000-0000-0000-0010
    118 #define SCI_ENABLE_RCVR         0x0004          // 0000-0000-0000-0100
    119 #define SCI_ENABLE_XMTR         0x0008          // 0000-0000-0000-1000
    120 
    121 #define SCI_DISABLE_RCVR        0xFFFB          // 1111-1111-1111-1011
    122 #define SCI_DISABLE_XMTR        0xFFF7          // 1111-1111-1111-0111
    123 
    124 #define SCI_ENABLE_INT_IDLE     0x0010          // 0000-0000-0001-0000
    125 #define SCI_ENABLE_INT_RX       0x0020          // 0000-0000-0010-0000
    126 #define SCI_ENABLE_INT_TX_DONE  0x0040          // 0000-0000-0100-0000
    127 #define SCI_ENABLE_INT_TX       0x0080          // 0000-0000-1000-0000
    128 
    129 #define SCI_DISABLE_INT_ALL     0xFF00          // 1111-1111-0000-0000 ???
    130 
    131 #define SCI_DISABLE_INT_RX      0xFFDF          // 1111-1111-1101-1111
    132 #define SCI_CLEAR_RX_INT        0xFFBF          // 1111-1111-1011-1111
    133 #define SCI_DISABLE_INT_TX      0xFF7F          // 1111-1111-0111-1111
    134 #define SCI_CLEAR_TDRE          0xFEFF          // 1111-1110-1111-1111
    135 
    136 #define SCI_RCVR_WAKE_ON_MARK   0x0100          // 0000-0001-0000-0000
    137 #define SCI_9_DATA_BITS         0x0200          // 0000-0010-0000-0000
    138 #define SCI_PARITY_ENABLE       0x0400          // 0000-0100-0000-0000
    139 #define SCI_PARITY_ODD          0x0800          // 0000-1000-0000-0000
    140 
    141 #define SCI_RCVR_WAKE_ON_IDLE   0xFEFF          // 1111-1110-1111-1111
    142 #define SCI_8_DATA_BITS         0xFDFF          // 1111-1101-1111-1111
    143 #define SCI_PARITY_DISABLE      0xFBFF          // 1111-1011-1111-1111
    144 #define SCI_PARITY_EVEN         0xF7FF          // 1111-0111-1111-1111
    145 
    146 #define SCI_PARITY_NONE         0xF3FF          // 1111-0011-1111-1111
    147 
    148 #define SCI_IDLE_LINE_LONG      0x1000          // 0001-0000-0000-0000
    149 #define SCI_TXD_OPEN_DRAIN      0x2000          // 0010-0000-0000-0000
    150 #define SCI_LOOPBACK_MODE       0x4000          // 0100-0000-0000-0000
    151 #define SCI_SCCR1_UNUSED        0x8000          // 1000-0000-0000-0000
    152 
    153 
    154 
    155 //  SCI Status Register  (SCSR)  $FFFC0C
    156 
    157 //  8 4 2 1 - 8 4 2 1 - 8 4 2 1 - 8 4 2 1
    158 //  ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^
    159 //  | | | |   | | | |   | | | |   | | | |
    160 //  | | | |   | | | |   | | | |   | | | +-----   0 PF - parity error
    161 //  | | | |   | | | |   | | | |   | | +-------   1 FE - framing error
    162 //  | | | |   | | | |   | | | |   | +---------   2 NF - noise flag
    163 //  | | | |   | | | |   | | | |   +-----------   3 OR - overrun flag
    164 //  | | | |   | | | |   | | | |
    165 //  | | | |   | | | |   | | | +---------------   4 IDLE - idle line detected
    166 //  | | | |   | | | |   | | +-----------------   5 RAF  - rcvr active flag
    167 //  | | | |   | | | |   | +-------------------   6 RDRF - rcv data reg full
    168 //  | | | |   | | | |   +---------------------   7 TC   - xmt complete flag
    169 //  | | | |   | | | |
    170 //  | | | |   | | | +-------------------------   8 TDRE - xmt data reg empty
    171 //  | | | |   | | +---------------------------   9 always zero
    172 //  | | | |   | +-----------------------------  10 always zero
    173 //  | | | |   +-------------------------------  11 always zero
    174 //  | | | |
    175 //  | | | +-----------------------------------  12 always zero
    176 //  | | +-------------------------------------  13 always zero
    177 //  | +---------------------------------------  14 always zero
    178 //  +-----------------------------------------  15 always zero
    179 
    180 //  0 0 0 0 - 0 0 0 1 - 1 0 0 0 - 0 0 0 0       reset value
    181 
    182 #define SCI_ERROR_PARITY        0x0001          // 0000-0000-0000-0001
    183 #define SCI_ERROR_FRAMING       0x0002          // 0000-0000-0000-0010
    184 #define SCI_ERROR_NOISE         0x0004          // 0000-0000-0000-0100
    185 #define SCI_ERROR_OVERRUN       0x0008          // 0000-0000-0000-1000
    186 
    187 #define SCI_IDLE_LINE           0x0010          // 0000-0000-0001-0000
    188 #define SCI_RCVR_ACTIVE         0x0020          // 0000-0000-0010-0000
    189 #define SCI_RCVR_READY          0x0040          // 0000-0000-0100-0000
    190 #define SCI_XMTR_IDLE           0x0080          // 0000-0000-1000-0000
    191 
    192 #define SCI_CLEAR_RX_INT        0xFFBF          // 1111-1111-1011-1111
    193 
    194 #define SCI_XMTR_READY          0x0100          // 0000-0001-0000-0000
    195 
    196 #define SCI_CLEAR_TDRE          0xFEFF          // 1111-1110-1111-1111
    197 
    198 #define SCI_XMTR_AVAILABLE      0x0180          // 0000-0001-1000-0000
     90/*  SCI Control Register 1  (SCCR1)  $FFFC0A
     91
     92    8 4 2 1 - 8 4 2 1 - 8 4 2 1 - 8 4 2 1
     93    ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^
     94    | | | |   | | | |   | | | |   | | | |
     95    | | | |   | | | |   | | | |   | | | +-----   0 send a break
     96    | | | |   | | | |   | | | |   | | +-------   1 rcvr wakeup mode
     97    | | | |   | | | |   | | | |   | +---------   2 rcvr enable
     98    | | | |   | | | |   | | | |   +-----------   3 xmtr enable
     99    | | | |   | | | |   | | | |
     100    | | | |   | | | |   | | | +---------------   4 idle line intr enable
     101    | | | |   | | | |   | | +-----------------   5 rcvr intr enable
     102    | | | |   | | | |   | +-------------------   6 xmit complete intr enable
     103    | | | |   | | | |   +---------------------   7 xmtr intr enable
     104    | | | |   | | | |
     105    | | | |   | | | +-------------------------   8 wakeup on address mark
     106    | | | |   | | +---------------------------   9 mode 1=9 bits, 0=8 bits
     107    | | | |   | +-----------------------------  10 parity enable 1=on, 0=off
     108    | | | |   +-------------------------------  11 parity type 1=odd, 0=even
     109    | | | |
     110    | | | +-----------------------------------  12 idle line select
     111    | | +-------------------------------------  13 wired-or mode
     112    | +---------------------------------------  14 loop mode
     113    +-----------------------------------------  15 unused
     114 
     115    0 0 0 0 - 0 0 0 0 - 0 0 0 0 - 0 0 0 0       reset value
     116*/
     117
     118#define SCI_SEND_BREAK          0x0001          /* 0000-0000-0000-0001 */
     119#define SCI_RCVR_WAKEUP         0x0002          /* 0000-0000-0000-0010 */
     120#define SCI_ENABLE_RCVR         0x0004          /* 0000-0000-0000-0100 */
     121#define SCI_ENABLE_XMTR         0x0008          /* 0000-0000-0000-1000 */
     122
     123#define SCI_DISABLE_RCVR        0xFFFB          /* 1111-1111-1111-1011 */
     124#define SCI_DISABLE_XMTR        0xFFF7          /* 1111-1111-1111-0111 */
     125
     126#define SCI_ENABLE_INT_IDLE     0x0010          /* 0000-0000-0001-0000 */
     127#define SCI_ENABLE_INT_RX       0x0020          /* 0000-0000-0010-0000 */
     128#define SCI_ENABLE_INT_TX_DONE  0x0040          /* 0000-0000-0100-0000 */
     129#define SCI_ENABLE_INT_TX       0x0080          /* 0000-0000-1000-0000 */
     130
     131#define SCI_DISABLE_INT_ALL     0xFF00          /* 1111-1111-0000-0000 ??? */
     132
     133#define SCI_DISABLE_INT_RX      0xFFDF          /* 1111-1111-1101-1111 */
     134#define SCI_CLEAR_RX_INT        0xFFBF          /* 1111-1111-1011-1111 */
     135#define SCI_DISABLE_INT_TX      0xFF7F          /* 1111-1111-0111-1111 */
     136#define SCI_CLEAR_TDRE          0xFEFF          /* 1111-1110-1111-1111 */
     137
     138#define SCI_RCVR_WAKE_ON_MARK   0x0100          /* 0000-0001-0000-0000 */
     139#define SCI_9_DATA_BITS         0x0200          /* 0000-0010-0000-0000 */
     140#define SCI_PARITY_ENABLE       0x0400          /* 0000-0100-0000-0000 */
     141#define SCI_PARITY_ODD          0x0800          /* 0000-1000-0000-0000 */
     142
     143#define SCI_RCVR_WAKE_ON_IDLE   0xFEFF          /* 1111-1110-1111-1111 */
     144#define SCI_8_DATA_BITS         0xFDFF          /* 1111-1101-1111-1111 */
     145#define SCI_PARITY_DISABLE      0xFBFF          /* 1111-1011-1111-1111 */
     146#define SCI_PARITY_EVEN         0xF7FF          /* 1111-0111-1111-1111 */
     147
     148#define SCI_PARITY_NONE         0xF3FF          /* 1111-0011-1111-1111 */
     149
     150#define SCI_IDLE_LINE_LONG      0x1000          /* 0001-0000-0000-0000 */
     151#define SCI_TXD_OPEN_DRAIN      0x2000          /* 0010-0000-0000-0000 */
     152#define SCI_LOOPBACK_MODE       0x4000          /* 0100-0000-0000-0000 */
     153#define SCI_SCCR1_UNUSED        0x8000          /* 1000-0000-0000-0000 */
     154
     155
     156
     157/*  SCI Status Register  (SCSR)  $FFFC0C
     158
     159    8 4 2 1 - 8 4 2 1 - 8 4 2 1 - 8 4 2 1
     160    ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^   ^ ^ ^ ^
     161    | | | |   | | | |   | | | |   | | | |
     162    | | | |   | | | |   | | | |   | | | +-----   0 PF - parity error
     163    | | | |   | | | |   | | | |   | | +-------   1 FE - framing error
     164    | | | |   | | | |   | | | |   | +---------   2 NF - noise flag
     165    | | | |   | | | |   | | | |   +-----------   3 OR - overrun flag
     166    | | | |   | | | |   | | | |
     167    | | | |   | | | |   | | | +---------------   4 IDLE - idle line detected
     168    | | | |   | | | |   | | +-----------------   5 RAF  - rcvr active flag
     169    | | | |   | | | |   | +-------------------   6 RDRF - rcv data reg full
     170    | | | |   | | | |   +---------------------   7 TC   - xmt complete flag
     171    | | | |   | | | |
     172    | | | |   | | | +-------------------------   8 TDRE - xmt data reg empty
     173    | | | |   | | +---------------------------   9 always zero
     174    | | | |   | +-----------------------------  10 always zero
     175    | | | |   +-------------------------------  11 always zero
     176    | | | |
     177    | | | +-----------------------------------  12 always zero
     178    | | +-------------------------------------  13 always zero
     179    | +---------------------------------------  14 always zero
     180    +-----------------------------------------  15 always zero
     181 
     182    0 0 0 0 - 0 0 0 1 - 1 0 0 0 - 0 0 0 0       reset value
     183*/
     184
     185#define SCI_ERROR_PARITY        0x0001          /* 0000-0000-0000-0001 */
     186#define SCI_ERROR_FRAMING       0x0002          /* 0000-0000-0000-0010 */
     187#define SCI_ERROR_NOISE         0x0004          /* 0000-0000-0000-0100 */
     188#define SCI_ERROR_OVERRUN       0x0008          /* 0000-0000-0000-1000 */
     189
     190#define SCI_IDLE_LINE           0x0010          /* 0000-0000-0001-0000 */
     191#define SCI_RCVR_ACTIVE         0x0020          /* 0000-0000-0010-0000 */
     192#define SCI_RCVR_READY          0x0040          /* 0000-0000-0100-0000 */
     193#define SCI_XMTR_IDLE           0x0080          /* 0000-0000-1000-0000 */
     194
     195#define SCI_CLEAR_RX_INT        0xFFBF          /* 1111-1111-1011-1111 */
     196
     197#define SCI_XMTR_READY          0x0100          /* 0000-0001-0000-0000 */
     198
     199#define SCI_CLEAR_TDRE          0xFEFF          /* 1111-1110-1111-1111 */
     200
     201#define SCI_XMTR_AVAILABLE      0x0180          /* 0000-0001-1000-0000 */
    199202
    200203
     
    209212#endif
    210213
    211 // look at console_open to see how this is called
     214/* look at console_open to see how this is called */
    212215
    213216const rtems_termios_callbacks * SciGetTermiosHandlers( int32_t   polled );
     
    215218/* SCI interrupt */
    216219
    217 //rtems_isr SciIsr( rtems_vector_number vector );
    218 
    219 //int32_t   SciOpenPolled    ( int32_t   major, int32_t   minor, void *arg );
    220 //int32_t   SciOpenInterrupt ( int32_t   major, int32_t   minor, void *arg );
    221 
    222 //int32_t   SciClose         ( int32_t   major, int32_t   minor, void *arg );
    223 
    224 //int32_t   SciWritePolled   ( int32_t   minor, const char *buf, int32_t   len );
    225 //int32_t   SciWriteInterrupt( int32_t   minor, const char *buf, int32_t   len );
    226 
    227 //int32_t   SciReadPolled    ( int32_t   minor );
    228 
    229 //int32_t   SciSetAttributes ( int32_t   minor, const struct termios *t );
     220/*rtems_isr SciIsr( rtems_vector_number vector ); */
     221
     222/*int32_t   SciOpenPolled    ( int32_t   major, int32_t   minor, void *arg ); */
     223/*int32_t   SciOpenInterrupt ( int32_t   major, int32_t   minor, void *arg ); */
     224
     225/*int32_t   SciClose         ( int32_t   major, int32_t   minor, void *arg ); */
     226
     227/*int32_t   SciWritePolled   ( int32_t   minor, const char *buf, int32_t   len ); */
     228/*int32_t   SciWriteInterrupt( int32_t   minor, const char *buf, int32_t   len ); */
     229
     230/*int32_t   SciReadPolled    ( int32_t   minor ); */
     231
     232/*int32_t   SciSetAttributes ( int32_t   minor, const struct termios *t ); */
    230233
    231234#ifdef __cplusplus
     
    233236#endif
    234237
    235 #endif  // _sci_h_
     238#endif  /* _sci_h_ */
  • c/src/lib/libbsp/m68k/mrm332/spurious/spinit.c

    r1883c87 rda2fc6c0  
    3434)
    3535{
    36   //int sp = 0;
     36  /*int sp = 0; */
    3737#if 0
    3838  const char * const VectDescrip[] = {
     
    6161#endif
    6262
    63   //asm volatile ( "movea.l   %%sp,%0 " : "=a" (sp) : "0" (sp) );
     63  /*asm volatile ( "movea.l   %%sp,%0 " : "=a" (sp) : "0" (sp) ); */
    6464
    6565  _CPU_ISR_Set_level( 7 );
    66   //_UART_flush();
     66  /*_UART_flush(); */
    6767#if 0
    6868  RAW_PUTS("\n\rRTEMS: Spurious interrupt: ");
  • c/src/lib/libbsp/m68k/mrm332/startup/bspclean.c

    r1883c87 rda2fc6c0  
    2424    /* interrupt driven stdio must be flushed */
    2525    _CPU_ISR_Set_level( 7 );
    26     //_UART_flush();
     26    /*_UART_flush(); */
    2727}
  • c/src/lib/libbsp/m68k/mrm332/startup/start_c.c

    r1883c87 rda2fc6c0  
    115115  /* Spurious should be called in the predriver hook */
    116116  /* Spurious_Initialize(); */
    117   //console_init();
     117  /*console_init(); */
    118118
    119119  /*
Note: See TracChangeset for help on using the changeset viewer.