Changeset 2afd852a in rtems


Ignore:
Timestamp:
May 3, 2005, 6:48:32 PM (15 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
dc5e3d4f
Parents:
e54db8b
Message:

2005-05-03 Joel Sherrill <joel@…>

  • sh7045/sci/sci.c, sh7045/sci/sci_termios.c: Remove warnings.
Location:
c/src/lib/libcpu/sh
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libcpu/sh/ChangeLog

    re54db8b r2afd852a  
     12005-05-03      Joel Sherrill <joel@OARcorp.com>
     2
     3        * sh7045/sci/sci.c, sh7045/sci/sci_termios.c: Remove warnings.
     4
    152005-03-14      Joel Sherrill <joel@OARcorp.com>
    26
  • c/src/lib/libcpu/sh/sh7045/sci/sci.c

    re54db8b r2afd852a  
    7878
    7979struct scidev_t {
    80   char *                        name ;
    81   uint32_t                      addr ;
    82   rtems_device_minor_number     minor ;
    83   unsigned short                opened ;
    84   tcflag_t                      cflags ;
     80  char *                        name;
     81  uint32_t                      addr;
     82  rtems_device_minor_number     minor;
     83  unsigned short                opened;
     84  tcflag_t                      cflags;
    8585} sci_device[SCI_MINOR_DEVICES] =
    8686{
    8787  { "/dev/sci0", SH_SCI_BASE_0, 0, 0, SH_SCI_DEF_COMM_0 },
    8888  { "/dev/sci1", SH_SCI_BASE_1, 1, 0, SH_SCI_DEF_COMM_1 }
    89 } ;
     89};
    9090
    9191/*  local data structures maintain hardware configuration */
     
    9898  tcflag_t      cflag,
    9999  unsigned char *smr,
    100   unsigned char *brr );
     100  unsigned char *brr
     101);
    101102
    102103/* Translate termios' tcflag_t into sci settings */
    103104static int _sci_set_cflags(
    104   struct scidev_t      *sci_dev,
    105   tcflag_t      c_cflag )
    106 {
    107   uint8_t       smr ;
    108   uint8_t       brr ;
     105  struct scidev_t  *sci_dev,
     106  tcflag_t          c_cflag
     107)
     108{
     109  uint8_t       smr;
     110  uint8_t       brr;
    109111
    110112  if ( c_cflag & CBAUD )
    111113  {
    112114    if ( _sci_get_brparms( c_cflag, &smr, &brr ) != 0 )
    113       return -1 ;
     115      return -1;
    114116  }
    115117
     
    121123      smr |= SCI_SEVEN_BIT_DATA;
    122124    else
    123       return -1 ;
     125      return -1;
    124126  }
    125127
     
    130132
    131133  if ( c_cflag & PARENB )
    132     smr |= SCI_PARITY_ON ;
     134    smr |= SCI_PARITY_ON;
    133135  else
    134     smr &= ~SCI_PARITY_ON ;
     136    smr &= ~SCI_PARITY_ON;
    135137
    136138  if ( c_cflag & PARODD )
    137     smr |= SCI_ODD_PARITY ;
     139    smr |= SCI_ODD_PARITY;
    138140  else
    139141    smr &= ~SCI_ODD_PARITY;
     
    142144  write8( brr, sci_dev->addr + SCI_BRR );
    143145
    144   return 0 ;
     146  return 0;
    145147}
    146148
     
    214216    write8(temp, SCI_SSR0);
    215217    /* Check for transmission errors */
    216     if(temp & (SCI_ORER | SCI_FER | SCI_PER)){
     218    if (temp & (SCI_ORER | SCI_FER | SCI_PER)) {
    217219        /* TODO: report to RTEMS transmission error */
    218220
     
    238240    write8(temp, SCI_SSR1);
    239241    /* Check for transmission errors */
    240     if(temp & (SCI_ORER | SCI_FER | SCI_PER)){
     242    if (temp & (SCI_ORER | SCI_FER | SCI_PER)) {
    241243        /* TODO: report to RTEMS transmission error */
    242244
     
    252254
    253255/* initial version pulls byte from selected port */
    254 char sh_sci_inbyte_polled(
    255     rtems_device_minor_number  minor )
    256 {
    257         char ch;
    258 
    259         if (minor == 0) /* blocks until char.ready */
    260                 while (rdSCI0(&ch) != TRUE); /* SCI0 */
    261         else
    262                 while (rdSCI1(&ch) != TRUE); /* SCI1 */
    263         return ch;
     256char sh_sci_inbyte_polled( rtems_device_minor_number  minor )
     257{
     258  uint8_t ch = 0;
     259
     260  if (minor == 0) /* blocks until char.ready */
     261    while (rdSCI0(&ch) != TRUE); /* SCI0 */
     262  else
     263    while (rdSCI1(&ch) != TRUE); /* SCI1 */
     264  return ch;
    264265} /* sh_sci_inbyte_polled */
    265266
    266267/* Initial version calls polled input driver */
    267 char inbyte(
    268   rtems_device_minor_number  minor )
    269 {
    270         char ch;
    271 
    272         ch = sh_sci_inbyte_polled(minor);
    273         return ch;
     268char inbyte( rtems_device_minor_number  minor )
     269{
     270  char ch;
     271
     272  ch = sh_sci_inbyte_polled(minor);
     273  return ch;
    274274} /* inbyte */
    275275
     
    312312        sci_device[i].name,
    313313        &driver);
    314     if( status != RTEMS_SUCCESSFUL )
     314    if ( status != RTEMS_SUCCESSFUL )
    315315    {
    316316        /* OK. We assume it is not registered yet. */
     
    343343  uint16_t   temp16;
    344344
    345   unsigned      a ;
     345  unsigned      a;
    346346
    347347 /* check for valid minor number */
    348    if(( minor > ( SCI_MINOR_DEVICES -1 )) || ( minor < 0 ))
     348   if (( minor > ( SCI_MINOR_DEVICES -1 )) || ( minor < 0 ))
    349349   {
    350350     return RTEMS_INVALID_NUMBER;
     
    354354  if ( sci_device[minor].opened > 0 )
    355355  {
    356     sci_device[minor].opened++ ;
    357     return RTEMS_SUCCESSFUL ;
     356    sci_device[minor].opened++;
     357    return RTEMS_SUCCESSFUL;
    358358  }
    359359
     
    379379    _sci_set_cflags( &sci_device[minor], sci_device[minor].cflags );
    380380
    381     for(a=0; a < 10000L; a++) {                      /* Delay */
     381    for (a=0; a < 10000L; a++) {                      /* Delay */
    382382      asm volatile ("nop");
    383383    }
     
    388388    /* clear error flags */
    389389    temp8 = read8(sci_device[minor].addr + SCI_SSR);
    390     while(temp8 & (SCI_RDRF | SCI_ORER | SCI_FER | SCI_PER)){
     390    while (temp8 & (SCI_RDRF | SCI_ORER | SCI_FER | SCI_PER)) {
    391391        temp8 = read8(sci_device[minor].addr + SCI_RDR);   /* flush input */
    392392        temp8 = read8(sci_device[minor].addr + SCI_SSR); /* clear some flags */
     
    404404
    405405
    406   sci_device[minor].opened++ ;
    407 
    408   return RTEMS_SUCCESSFUL ;
     406  sci_device[minor].opened++;
     407
     408  return RTEMS_SUCCESSFUL;
    409409}
    410410
     
    421421  /* FIXME: Incomplete */
    422422  if ( sci_device[minor].opened > 0 )
    423     sci_device[minor].opened-- ;
     423    sci_device[minor].opened--;
    424424  else
    425     return RTEMS_INVALID_NUMBER ;
    426 
    427   return RTEMS_SUCCESSFUL ;
     425    return RTEMS_INVALID_NUMBER;
     426
     427  return RTEMS_SUCCESSFUL;
    428428}
    429429
     
    502502{
    503503  /* Not yet supported */
    504   return RTEMS_SUCCESSFUL ;
     504  return RTEMS_SUCCESSFUL;
    505505}
    506506
     
    526526static int _sh_sci_poll_read(int minor)
    527527{
    528     int value = -1;
    529     char ch;
    530 
    531     if( minor == 0 ){
    532         if( rdSCI0( &ch ) )
    533             value = (int) ch;
    534     }else if( minor == 1 ){
    535         if( rdSCI1( &ch ) )
    536             value = (int) ch;
    537     }
    538     return value;
     528  int value = -1;
     529  uint8_t ch = 0;
     530
     531  if ( minor == 0 ) {
     532    if ( rdSCI0( &ch ) )
     533      value = (int) ch;
     534  } else if ( minor == 1 ) {
     535    if ( rdSCI1( &ch ) )
     536      value = (int) ch;
     537  }
     538  return value;
    539539}
    540540
     
    542542 * Termios polled write
    543543 */
    544 static int _sh_sci_poll_write(int minor, const char *buf, int len)
     544static int _sh_sci_poll_write(int minor, const uint8_t *buf, int len)
    545545{
    546546    int count;
    547547
    548     for(count = 0; count < len; count++)
     548    for (count = 0; count < len; count++)
    549549        outbyte( minor, buf[count] );
    550550    return count;
  • c/src/lib/libcpu/sh/sh7045/sci/sci_termios.c

    re54db8b r2afd852a  
    6262  tcflag_t      cflag,
    6363  unsigned char *smr,
    64   unsigned char *brr );
     64  unsigned char *brr
     65);
    6566
    6667/*
     
    7273)
    7374{
    74     uint8_t     smr ;
    75     uint8_t     brr ;
     75    uint8_t     smr;
     76    uint8_t     brr;
    7677    int a;
    7778
    7879    tcflag_t c_cflag = t->c_cflag;
    7980
    80     if ( c_cflag & CBAUD )
    81     {
     81    if ( c_cflag & CBAUD ) {
    8282        if ( _sci_get_brparms( c_cflag, &smr, &brr ) != 0 )
    8383            return -1 ;
    8484    }
    8585
    86     if ( c_cflag & CSIZE )
    87     {
     86    if ( c_cflag & CSIZE ) {
    8887        if ( c_cflag & CS8 )
    8988            smr &= ~SCI_SEVEN_BIT_DATA;
     
    114113    SH_SCI_REG_DATA(brr, minor, SCI_BRR);
    115114
    116     for(a=0; a < 10000L; a++) { /* Delay one bit */
     115    for (a=0; a < 10000L; a++) { /* Delay one bit */
    117116        asm volatile ("nop");
    118117    }
     
    132131    int minor;
    133132
    134     for(minor = 0; minor < Console_Port_Count; minor++)
    135     {
    136         if(Console_Port_Tbl[minor].ulIntVector == vector)
    137         {
    138             uint8_t   temp8;
     133    for (minor = 0; minor < Console_Port_Count; minor++) {
     134        if (Console_Port_Tbl[minor].ulIntVector == vector) {
     135            char   temp8;
    139136
    140137            /*
     
    144141
    145142            rtems_termios_enqueue_raw_characters(
    146                 Console_Port_Data[minor].termios_data,
    147                 (char*)&temp8, 1);
     143                Console_Port_Data[minor].termios_data, &temp8, 1);
    148144
    149145            SH_SCI_REG_MASK(SCI_RDRF, minor, SCI_SSR);
     
    162158    int minor;
    163159
    164     for(minor = 0; minor < Console_Port_Count; minor++)
    165     {
    166         if(Console_Port_Tbl[minor].ulDataPort == vector)
    167         {
     160    for (minor = 0; minor < Console_Port_Count; minor++) {
     161        if (Console_Port_Tbl[minor].ulDataPort == vector) {
    168162            /*
    169163             * FIXME: Error handling should be added
     
    175169            SH_SCI_REG_MASK(SCI_TIE, minor, SCI_SCR);
    176170
    177             if(rtems_termios_dequeue_characters(
    178                    Console_Port_Data[minor].termios_data, 1))
    179             {
     171            if (rtems_termios_dequeue_characters(
     172                   Console_Port_Data[minor].termios_data, 1)) {
    180173                /*
    181174                 * More characters to be received - interrupt must be enabled
     
    199192     * set PFC registers to enable I/O pins
    200193     */
    201     if ((minor == 0))
    202     {
     194    if ((minor == 0)) {
    203195        temp16 = read16(PFC_PACRL2);         /* disable SCK0, DMA, IRQ */
    204196        temp16 &= ~(PA2MD1 | PA2MD0);
     
    206198        write16(temp16, PFC_PACRL2);
    207199
    208     }
    209     else if (minor == 1)
    210     {
     200    } else if (minor == 1) {
    211201        temp16 = read16(PFC_PACRL2);          /* disable SCK1, DMA, IRQ */
    212202        temp16 &= ~(PA5MD1 | PA5MD0);
     
    235225     * Disable IRQ of SCIx
    236226     */
    237     status = sh_set_irq_priority(
    238         Console_Port_Tbl[minor].ulIntVector, 0);
    239 
    240     if(status != RTEMS_SUCCESSFUL)
     227    status = sh_set_irq_priority( Console_Port_Tbl[minor].ulIntVector, 0);
     228
     229    if (status != RTEMS_SUCCESSFUL)
    241230        rtems_fatal_error_occurred(status);
    242231
     
    251240        &old_isr);
    252241
    253     if(status != RTEMS_SUCCESSFUL)
     242    if (status != RTEMS_SUCCESSFUL)
    254243        rtems_fatal_error_occurred(status);
    255244
     
    259248        &old_isr);
    260249
    261     if(status != RTEMS_SUCCESSFUL)
     250    if (status != RTEMS_SUCCESSFUL)
    262251        rtems_fatal_error_occurred(status);
    263252
     
    271260        Console_Port_Tbl[minor].ulCtrlPort2);
    272261
    273     if(status != RTEMS_SUCCESSFUL)
     262    if (status != RTEMS_SUCCESSFUL)
    274263        rtems_fatal_error_occurred(status);
    275264}
     
    284273  int major,
    285274  int minor,
    286   void *arg )
    287 {
    288     uint8_t   temp8;
     275  void *arg
     276)
     277{
     278    char   temp8;
    289279    unsigned int a ;
    290280
     
    292282     * check for valid minor number
    293283     */
    294     if(( minor > ( SCI_MINOR_DEVICES -1 )) || ( minor < 0 ))
    295     {
     284    if (( minor > ( SCI_MINOR_DEVICES -1 )) || ( minor < 0 )) {
    296285        return RTEMS_INVALID_NUMBER;
    297286    }
     
    306295    sh_sci_set_attributes(minor, Console_Port_Tbl[minor].pDeviceParams);
    307296
    308     for(a=0; a < 10000L; a++) {                      /* Delay */
     297    for (a=0; a < 10000L; a++) {                      /* Delay */
    309298        asm volatile ("nop");
    310299    }
     
    317306     */
    318307    temp8 = read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_SSR);
    319     while(temp8 & (SCI_RDRF | SCI_ORER | SCI_FER | SCI_PER))
    320     {
     308    while(temp8 & (SCI_RDRF | SCI_ORER | SCI_FER | SCI_PER)) {
    321309        /* flush input */
    322310        temp8 = read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_RDR);
     
    338326     * Interrupt setup
    339327     */
    340     if(Console_Port_Tbl[minor].pDeviceFns->deviceOutputUsesInterrupts)
    341     {
     328    if (Console_Port_Tbl[minor].pDeviceFns->deviceOutputUsesInterrupts) {
    342329        SH_SCI_REG_FLAG(SCI_RIE, minor, SCI_SCR);
    343330    }
     
    359346
    360347    /* Shutdown interrupts if necessary */
    361     if(Console_Port_Tbl[minor].pDeviceFns->deviceOutputUsesInterrupts)
     348    if (Console_Port_Tbl[minor].pDeviceFns->deviceOutputUsesInterrupts)
    362349    {
    363350        SH_SCI_REG_MASK((SCI_TIE | SCI_RIE), minor, SCI_SCR);
     
    370357 */
    371358int sh_sci_write_support_int(
    372     int         minor,
    373     const char *buf,
    374     int         len
    375 )
    376 {
    377     if(!len)
     359  int            minor,
     360  const char    *buf,
     361  int            len
     362)
     363{
     364    if (!len)
    378365        return 0;
    379366    /*
     
    394381 */
    395382int sh_sci_write_support_polled(
    396   int   minor,
    397   const char *buf,
    398   int   len
     383  int            minor,
     384  const char    *buf,
     385  int            len
    399386)
    400387{
    401388    int count = 0;
    402389
    403     while(count < len)
    404     {
     390    while(count < len) {
    405391        sh_sci_write_polled(minor, buf[count]);
    406392        count++;
     
    416402 */
    417403void sh_sci_write_polled(
    418     int minor,
    419     char c
     404  int    minor,
     405  char    c
    420406)
    421407{
     
    440426int sh_sci_inbyte_nonblocking_polled(int minor)
    441427{
    442     uint8_t   inbyte;
     428    char   inbyte;
    443429
    444430    /*
    445431     * Check if input buffer is full
    446432     */
    447     if(read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_SSR) & SCI_RDRF)
    448     {
     433    if (read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_SSR) & SCI_RDRF) {
    449434        inbyte = read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_RDR);
    450435        SH_SCI_REG_MASK(SCI_RDRF, minor, SCI_SSR);
     
    453438         * Check for errors
    454439         */
    455         if(read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_SSR) &
    456            (SCI_ORER | SCI_FER | SCI_PER))
    457         {
     440        if (read8(Console_Port_Tbl[minor].ulCtrlPort1 + SCI_SSR) &
     441           (SCI_ORER | SCI_FER | SCI_PER)) {
    458442            SH_SCI_REG_MASK((SCI_ORER | SCI_FER | SCI_PER), minor, SCI_SSR);
    459443            return -1;
Note: See TracChangeset for help on using the changeset viewer.