Changeset cd53898 in rtems


Ignore:
Timestamp:
Mar 14, 2005, 9:22:10 PM (16 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
c2701a0
Parents:
3adc6c13
Message:

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

  • sh7750/sci/sh4uart.c: Now compiles under gcc 4.x and reformatted.
Location:
c/src/lib/libcpu/sh
Files:
2 edited

Legend:

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

    r3adc6c13 rcd53898  
     12005-03-14      Joel Sherrill <joel@OARcorp.com>
     2
     3        * sh7750/sci/sh4uart.c: Now compiles under gcc 4.x and reformatted.
     4
    152005-01-07      Ralf Corsepius <ralf.corsepius@rtems.org>
    26
  • c/src/lib/libcpu/sh/sh7750/sci/sh4uart.c

    r3adc6c13 rcd53898  
    5454sh4uart_init(sh4uart *uart, void *tty, int chn, int int_driven)
    5555{
    56     if (uart == NULL)
    57         return RTEMS_INVALID_ADDRESS;
    58 
    59     if ((chn != SH4_SCI) && (chn != SH4_SCIF))
    60                 return RTEMS_INVALID_NUMBER;
    61 
    62     uart->chn = chn;
    63     uart->tty = tty;
    64     uart->int_driven = int_driven;
     56  if (uart == NULL)
     57    return RTEMS_INVALID_ADDRESS;
     58
     59  if ((chn != SH4_SCI) && (chn != SH4_SCIF))
     60    return RTEMS_INVALID_NUMBER;
     61
     62  uart->chn = chn;
     63  uart->tty = tty;
     64  uart->int_driven = int_driven;
    6565
    6666#if 0
    67     sh4uart_poll_write(uart, "init", 4);
     67  sh4uart_poll_write(uart, "init", 4);
    6868#endif
    69     return RTEMS_SUCCESSFUL;
     69  return RTEMS_SUCCESSFUL;
    7070}
    7171
     
    8484sh4uart_get_Pph(void)
    8585{
    86     uint16_t   frqcr = *(volatile uint16_t*)SH7750_FRQCR;
    87     uint32_t   Pph = CPU_CLOCK_RATE_HZ;
    88 
    89     switch (frqcr & SH7750_FRQCR_IFC)
    90     {
    91         case SH7750_FRQCR_IFCDIV1:
    92             break;
    93 
    94         case SH7750_FRQCR_IFCDIV2:
    95             Pph *= 2;
    96             break;
    97 
    98         case SH7750_FRQCR_IFCDIV3:
    99             Pph *= 3;
    100             break;
    101 
    102         case SH7750_FRQCR_IFCDIV4:
    103             Pph *= 4;
    104             break;
    105 
    106         case SH7750_FRQCR_IFCDIV6:
    107             Pph *= 6;
    108             break;
    109 
    110         case SH7750_FRQCR_IFCDIV8:
    111             Pph *= 8;
    112             break;
    113 
    114         default: /* unreachable */
    115             break;
    116     }
    117 
    118     switch (frqcr & SH7750_FRQCR_PFC)
    119     {
    120         case SH7750_FRQCR_PFCDIV2:
    121             Pph /= 2;
    122             break;
    123 
    124         case SH7750_FRQCR_PFCDIV3:
    125             Pph /= 3;
    126             break;
    127 
    128         case SH7750_FRQCR_PFCDIV4:
    129             Pph /= 4;
    130             break;
    131 
    132         case SH7750_FRQCR_PFCDIV6:
    133             Pph /= 6;
    134             break;
    135 
    136         case SH7750_FRQCR_PFCDIV8:
    137             Pph /= 8;
    138             break;
    139 
    140         default: /* unreachable */
    141             break;
    142     }
    143 
    144     return Pph;
     86  uint16_t   frqcr = *(volatile uint16_t*)SH7750_FRQCR;
     87  uint32_t   Pph = CPU_CLOCK_RATE_HZ;
     88
     89  switch (frqcr & SH7750_FRQCR_IFC) {
     90    case SH7750_FRQCR_IFCDIV1: break;
     91    case SH7750_FRQCR_IFCDIV2: Pph *= 2; break;
     92    case SH7750_FRQCR_IFCDIV3: Pph *= 3; break;
     93    case SH7750_FRQCR_IFCDIV4: Pph *= 4; break;
     94    case SH7750_FRQCR_IFCDIV6: Pph *= 6; break;
     95    case SH7750_FRQCR_IFCDIV8: Pph *= 8; break;
     96    default: /* unreachable */
     97      break;
     98  }
     99
     100  switch (frqcr & SH7750_FRQCR_PFC) {
     101    case SH7750_FRQCR_PFCDIV2: Pph /= 2; break;
     102    case SH7750_FRQCR_PFCDIV3: Pph /= 3; break;
     103    case SH7750_FRQCR_PFCDIV4: Pph /= 4; break;
     104    case SH7750_FRQCR_PFCDIV6: Pph /= 6; break;
     105    case SH7750_FRQCR_PFCDIV8: Pph /= 8; break;
     106    default: /* unreachable */
     107      break;
     108  }
     109
     110  return Pph;
    145111}
    146112
     
    162128sh4uart_set_baudrate(sh4uart *uart, speed_t baud)
    163129{
    164     uint32_t   rate;
    165     int16_t   div;
    166     int n;
    167     uint32_t   Pph = sh4uart_get_Pph();
    168 
    169     switch (baud)
    170     {
    171         case B50:     rate = 50; break;
    172         case B75:     rate = 75; break;
    173         case B110:    rate = 110; break;
    174         case B134:    rate = 134; break;
    175         case B150:    rate = 150; break;
    176         case B200:    rate = 200; break;
    177         case B300:    rate = 300; break;
    178         case B600:    rate = 600; break;
    179         case B1200:   rate = 1200; break;
    180         case B2400:   rate = 2400; break;
    181         case B4800:   rate = 4800; break;
    182         case B9600:   rate = 9600; break;
    183         case B19200:  rate = 19200; break;
    184         case B38400:  rate = 38400; break;
    185         case B57600:  rate = 57600; break;
     130  uint32_t   rate;
     131  int16_t   div;
     132  int n;
     133  uint32_t   Pph = sh4uart_get_Pph();
     134
     135  switch (baud) {
     136    case B50:     rate = 50; break;
     137    case B75:     rate = 75; break;
     138    case B110:    rate = 110; break;
     139    case B134:    rate = 134; break;
     140    case B150:    rate = 150; break;
     141    case B200:    rate = 200; break;
     142    case B300:    rate = 300; break;
     143    case B600:    rate = 600; break;
     144    case B1200:   rate = 1200; break;
     145    case B2400:   rate = 2400; break;
     146    case B4800:   rate = 4800; break;
     147    case B9600:   rate = 9600; break;
     148    case B19200:  rate = 19200; break;
     149    case B38400:  rate = 38400; break;
     150    case B57600:  rate = 57600; break;
    186151#ifdef B115200
    187         case B115200: rate = 115200; break;
     152    case B115200: rate = 115200; break;
    188153#endif
    189154#ifdef B230400
    190         case B230400: rate = 230400; break;
     155    case B230400: rate = 230400; break;
    191156#endif
    192         default:      rate = 9600; break;
    193     }
    194 
    195     for (n = 0; n < 4; n++)
    196     {
    197         div = Pph / (32 * (1 << (2 * n)) * rate) - 1;
    198         if (div < 0x100)
    199             break;
    200     }
    201 
    202     /* Set default baudrate if specified baudrate is impossible */
    203     if (n >= 4)
    204         sh4uart_set_baudrate(uart, B9600);
    205 
    206     SCSMR(uart->chn) &= ~SH7750_SCSMR_CKS;
    207     SCSMR(uart->chn) |= n << SH7750_SCSMR_CKS_S;
    208     SCBRR(uart->chn) = div;
    209     /* Whait at least 1 bit interwal */
    210     rtems_task_wake_after(RTEMS_MILLISECONDS_TO_TICKS(1000 / rate));
     157    default:      rate = 9600; break;
     158  }
     159
     160  for (n = 0; n < 4; n++) {
     161    div = Pph / (32 * (1 << (2 * n)) * rate) - 1;
     162    if (div < 0x100)
     163      break;
     164  }
     165
     166  /* Set default baudrate if specified baudrate is impossible */
     167  if (n >= 4)
     168    sh4uart_set_baudrate(uart, B9600);
     169
     170  if ( uart->chn == 1 ) {
     171    volatile uint8_t *smr1 = (volatile uint8_t *)SH7750_SCSMR1;
     172    *smr1 &= ~SH7750_SCSMR_CKS;
     173    *smr1 |= n << SH7750_SCSMR_CKS_S;
     174  } else {
     175    volatile uint16_t *smr2 = (volatile uint16_t *)SH7750_SCSMR2;
     176    *smr2 &= ~SH7750_SCSMR_CKS;
     177    *smr2 |= n << SH7750_SCSMR_CKS_S;
     178  }
     179
     180  SCBRR(uart->chn) = div;
     181  /* Wait at least 1 bit interwal */
     182  rtems_task_wake_after(RTEMS_MILLISECONDS_TO_TICKS(1000 / rate));
    211183}
    212184
     
    227199sh4uart_reset(sh4uart *uart)
    228200{
    229     register int chn;
    230     register int int_driven;
    231     rtems_status_code rc;
    232 
    233     if (uart == NULL)
    234         return RTEMS_INVALID_ADDRESS;
    235 
    236     chn = uart->chn;
    237     int_driven = uart->int_driven;
    238 
    239     SCSCR(chn) = 0x0;       /* Is set properly at the end of this function */
    240     SCSMR(chn) = 0x0;       /* 8-bit, non-parity, 1 stop bit, pf/1 clock */
    241 
    242     if (chn == SH4_SCIF)
    243         SCFCR2 = SH7750_SCFCR2_TFRST | SH7750_SCFCR2_RFRST |
    244                 SH7750_SCFCR2_RTRG_1 | SH7750_SCFCR2_TTRG_4;
    245 
    246     if (chn == SH4_SCI)
    247         SCSPTR1 = int_driven ? 0x0 : SH7750_SCSPTR1_EIO;
    248     else
    249         SCSPTR2 = SH7750_SCSPTR2_RTSDT;
    250 
    251     if (int_driven)
    252     {
    253         uint16_t   ipr;
    254 
    255         if (chn == SH4_SCI)
    256         {
    257             ipr = IPRB;
    258             ipr &= ~SH7750_IPRB_SCI1;
    259             ipr |= SH4_UART_INTERRUPT_LEVEL << SH7750_IPRB_SCI1_S;
    260             IPRB = ipr;
    261 
    262             rc = rtems_interrupt_catch(sh4uart1_interrupt_transmit,
    263                     SH7750_EVT_TO_NUM(SH7750_EVT_SCI_TXI),
    264                     &uart->old_handler_transmit);
    265             if (rc != RTEMS_SUCCESSFUL)
    266                 return rc;
    267             rc = rtems_interrupt_catch(sh4uart1_interrupt_receive,
    268                     SH7750_EVT_TO_NUM(SH7750_EVT_SCI_RXI),
    269                     &uart->old_handler_receive);
    270             if (rc != RTEMS_SUCCESSFUL)
    271                 return rc;
    272         }
    273         else
    274         {
    275             ipr = IPRC;
    276             ipr &= ~SH7750_IPRC_SCIF;
    277             ipr |= SH4_UART_INTERRUPT_LEVEL << SH7750_IPRC_SCIF_S;
    278             IPRC = ipr;
    279 
    280             rc = rtems_interrupt_catch(sh4uart2_interrupt_transmit,
    281                     SH7750_EVT_TO_NUM(SH7750_EVT_SCIF_TXI),
    282                     &uart->old_handler_transmit);
    283             if (rc != RTEMS_SUCCESSFUL)
    284                 return rc;
    285             rc = rtems_interrupt_catch(sh4uart2_interrupt_receive,
    286                     SH7750_EVT_TO_NUM(SH7750_EVT_SCIF_RXI),
    287                     &uart->old_handler_receive);
    288             if (rc != RTEMS_SUCCESSFUL)
    289                 return rc;
    290         }
    291         uart->tx_buf = NULL;
    292         uart->tx_ptr = uart->tx_buf_len = 0;
     201  register int chn;
     202  register int int_driven;
     203  rtems_status_code rc;
     204  uint16_t tmp;
     205
     206  if (uart == NULL)
     207    return RTEMS_INVALID_ADDRESS;
     208
     209  chn = uart->chn;
     210  int_driven = uart->int_driven;
     211
     212  if ( chn == 1 ) {
     213    volatile uint8_t *scr1 = (volatile uint8_t *)SH7750_SCSCR1;
     214    volatile uint8_t *smr1 = (volatile uint8_t *)SH7750_SCSMR1;
     215    *scr1 = 0x0;       /* Is set properly at the end of this function */
     216    *smr1 = 0x0;       /* 8-bit, non-parity, 1 stop bit, pf/1 clock */
     217  } else {
     218    volatile uint16_t *scr2 = (volatile uint16_t *)SH7750_SCSCR2;
     219    volatile uint16_t *smr2 = (volatile uint16_t *)SH7750_SCSMR2;
     220    *scr2 = 0x0;       /* Is set properly at the end of this function */
     221    *smr2 = 0x0;       /* 8-bit, non-parity, 1 stop bit, pf/1 clock */
     222  }
     223
     224  if (chn == SH4_SCIF)
     225    SCFCR2 = SH7750_SCFCR2_TFRST | SH7750_SCFCR2_RFRST |
     226             SH7750_SCFCR2_RTRG_1 | SH7750_SCFCR2_TTRG_4;
     227
     228  if (chn == SH4_SCI)
     229    SCSPTR1 = int_driven ? 0x0 : SH7750_SCSPTR1_EIO;
     230  else
     231    SCSPTR2 = SH7750_SCSPTR2_RTSDT;
     232
     233  if (int_driven) {
     234    uint16_t   ipr;
     235
     236    if (chn == SH4_SCI) {
     237      ipr = IPRB;
     238      ipr &= ~SH7750_IPRB_SCI1;
     239      ipr |= SH4_UART_INTERRUPT_LEVEL << SH7750_IPRB_SCI1_S;
     240      IPRB = ipr;
     241
     242      rc = rtems_interrupt_catch(sh4uart1_interrupt_transmit,
     243                                 SH7750_EVT_TO_NUM(SH7750_EVT_SCI_TXI),
     244                                 &uart->old_handler_transmit);
     245      if (rc != RTEMS_SUCCESSFUL)
     246        return rc;
     247
     248      rc = rtems_interrupt_catch(sh4uart1_interrupt_receive,
     249                                 SH7750_EVT_TO_NUM(SH7750_EVT_SCI_RXI),
     250                                 &uart->old_handler_receive);
     251      if (rc != RTEMS_SUCCESSFUL)
     252        return rc;
     253    } else {
     254      ipr = IPRC;
     255      ipr &= ~SH7750_IPRC_SCIF;
     256      ipr |= SH4_UART_INTERRUPT_LEVEL << SH7750_IPRC_SCIF_S;
     257      IPRC = ipr;
     258
     259      rc = rtems_interrupt_catch(sh4uart2_interrupt_transmit,
     260                                 SH7750_EVT_TO_NUM(SH7750_EVT_SCIF_TXI),
     261                                 &uart->old_handler_transmit);
     262      if (rc != RTEMS_SUCCESSFUL)
     263        return rc;
     264      rc = rtems_interrupt_catch(sh4uart2_interrupt_receive,
     265                                 SH7750_EVT_TO_NUM(SH7750_EVT_SCIF_RXI),
     266                                 &uart->old_handler_receive);
     267      if (rc != RTEMS_SUCCESSFUL)
     268        return rc;
    293269    }
    294 
    295     sh4uart_set_baudrate(uart, B38400); /* debug defaults (unfortunately,
    296                                            it is differ to termios default */
    297 
    298     SCSCR(chn) = SH7750_SCSCR_TE | SH7750_SCSCR_RE |
    299             (chn == SH4_SCI ? 0x0 : SH7750_SCSCR2_REIE) |
    300             (int_driven ? (SH7750_SCSCR_RIE | SH7750_SCSCR_TIE) : 0x0);
    301 
    302     return RTEMS_SUCCESSFUL;
     270    uart->tx_buf = NULL;
     271    uart->tx_ptr = uart->tx_buf_len = 0;
     272  }
     273
     274  sh4uart_set_baudrate(uart, B38400); /* debug defaults (unfortunately,
     275                                         it is differ to termios default */
     276
     277  tmp = SH7750_SCSCR_TE | SH7750_SCSCR_RE |
     278          (chn == SH4_SCI ? 0x0 : SH7750_SCSCR2_REIE) |
     279          (int_driven ? (SH7750_SCSCR_RIE | SH7750_SCSCR_TIE) : 0x0);
     280
     281  if ( chn == 1 ) {
     282    volatile uint8_t *scr = (volatile uint8_t *)SH7750_SCSCR1;
     283    *scr = tmp;
     284  } else {
     285    volatile uint16_t *scr = (volatile uint16_t *)SH7750_SCSCR2;
     286    *scr = tmp;
     287  }
     288
     289  return RTEMS_SUCCESSFUL;
    303290}
    304291
     
    318305sh4uart_disable(sh4uart *uart, int disable_port)
    319306{
    320     rtems_status_code rc;
    321 
    322     if (disable_port)
    323         SCSCR(uart->chn) &= ~(SH7750_SCSCR_TE | SH7750_SCSCR_RE);
    324 
    325     if (uart->int_driven)
    326     {
    327         rc = rtems_interrupt_catch(uart->old_handler_transmit,
    328                 uart->chn == SH4_SCI ?
    329                         SH7750_EVT_SCI_TXI : SH7750_EVT_SCIF_TXI,
    330                 NULL);
    331         if (rc != RTEMS_SUCCESSFUL)
    332             return rc;
    333         rc = rtems_interrupt_catch(uart->old_handler_receive,
    334                 uart->chn == SH4_SCI ?
    335                         SH7750_EVT_SCI_RXI : SH7750_EVT_SCIF_RXI,
    336                 NULL);
    337         if (rc != RTEMS_SUCCESSFUL)
    338             return rc;
     307  rtems_status_code rc;
     308
     309  if (disable_port) {
     310    if ( uart->chn == 1 ) {
     311      volatile uint8_t *scr = (volatile uint8_t *)SH7750_SCSCR1;
     312      *scr &= ~(SH7750_SCSCR_TE | SH7750_SCSCR_RE);
     313    } else {
     314      volatile uint16_t *scr = (volatile uint16_t *)SH7750_SCSCR2;
     315      *scr &= ~(SH7750_SCSCR_TE | SH7750_SCSCR_RE);
    339316    }
    340 
    341     return RTEMS_SUCCESSFUL;
     317  }
     318
     319  if (uart->int_driven) {
     320    rc = rtems_interrupt_catch(uart->old_handler_transmit,
     321           uart->chn == SH4_SCI ?  SH7750_EVT_SCI_TXI : SH7750_EVT_SCIF_TXI,
     322           NULL);
     323    if (rc != RTEMS_SUCCESSFUL)
     324      return rc;
     325    rc = rtems_interrupt_catch(uart->old_handler_receive,
     326           uart->chn == SH4_SCI ?  SH7750_EVT_SCI_RXI : SH7750_EVT_SCIF_RXI,
     327           NULL);
     328    if (rc != RTEMS_SUCCESSFUL)
     329      return rc;
     330  }
     331
     332  return RTEMS_SUCCESSFUL;
    342333}
    343334
     
    357348sh4uart_set_attributes(sh4uart *uart, const struct termios *t)
    358349{
    359     int level;
    360     speed_t baud;
    361     uint16_t   smr;
    362 
    363     smr = (uint16_t)(*(uint8_t*)SH7750_SCSMR(uart->chn));
    364 
    365     baud = cfgetospeed(t);
    366 
    367     /* Set flow control XXX*/
    368     if ((t->c_cflag & CRTSCTS) != 0)
    369     {
    370     }
    371 
    372     /* Set character size -- only 7 or 8 bit */
    373     switch (t->c_cflag & CSIZE)
    374     {
    375         case CS5:
    376         case CS6:
    377         case CS7: smr |= SH7750_SCSMR_CHR_7; break;
    378         case CS8: smr &= ~SH7750_SCSMR_CHR_7; break;
    379     }
     350  int level;
     351  speed_t baud;
     352  uint16_t   smr;
     353
     354  smr = (uint16_t)(*(uint8_t*)SH7750_SCSMR(uart->chn));
     355
     356  baud = cfgetospeed(t);
     357
     358  /* Set flow control XXX*/
     359  if ((t->c_cflag & CRTSCTS) != 0) {
     360  }
     361
     362  /* Set character size -- only 7 or 8 bit */
     363  switch (t->c_cflag & CSIZE) {
     364    case CS5:
     365    case CS6:
     366    case CS7: smr |= SH7750_SCSMR_CHR_7; break;
     367    case CS8: smr &= ~SH7750_SCSMR_CHR_7; break;
     368  }
    380369
    381370    /* Set number of stop bits */
    382     if ((t->c_cflag & CSTOPB) != 0)
    383         smr |= SH7750_SCSMR_STOP_2;
     371  if ((t->c_cflag & CSTOPB) != 0)
     372    smr |= SH7750_SCSMR_STOP_2;
     373  else
     374    smr &= ~SH7750_SCSMR_STOP_2;
     375
     376  /* Set parity mode */
     377  if ((t->c_cflag & PARENB) != 0) {
     378    smr |= SH7750_SCSMR_PE;
     379    if ((t->c_cflag & PARODD) != 0)
     380       smr |= SH7750_SCSMR_PM_ODD;
    384381    else
    385         smr &= ~SH7750_SCSMR_STOP_2;
    386 
    387     /* Set parity mode */
    388     if ((t->c_cflag & PARENB) != 0)
    389     {
    390         smr |= SH7750_SCSMR_PE;
    391         if ((t->c_cflag & PARODD) != 0)
    392            smr |= SH7750_SCSMR_PM_ODD;
    393         else
    394            smr &= ~SH7750_SCSMR_PM_ODD;
    395     }
    396     else
    397         smr &= ~SH7750_SCSMR_PE;
    398 
    399     rtems_interrupt_disable(level);
    400     /* wait untill all data is transmitted */
    401     rtems_task_wake_after(RTEMS_MILLISECONDS_TO_TICKS(100));
    402     /* disable operations */
    403     SCSCR(uart->chn) &= ~(SH7750_SCSCR_TE | SH7750_SCSCR_RE);
    404 
     382       smr &= ~SH7750_SCSMR_PM_ODD;
     383  } else
     384    smr &= ~SH7750_SCSMR_PE;
     385
     386  rtems_interrupt_disable(level);
     387  /* wait untill all data is transmitted */
     388  /* XXX JOEL says this is broken -- interrupts are OFF so NO ticks  */
     389  rtems_task_wake_after(RTEMS_MILLISECONDS_TO_TICKS(100));
     390
     391  if ( uart->chn == 1 ) {
     392    volatile uint8_t *scrP = (volatile uint8_t *)SH7750_SCSCR1;
     393    volatile uint8_t *smrP = (volatile uint8_t *)SH7750_SCSMR1;
     394
     395    *scrP &= ~(SH7750_SCSCR_TE | SH7750_SCSCR_RE); /* disable operations */
    405396    sh4uart_set_baudrate(uart, baud);
    406     SCSMR(uart->chn) = (uint8_t)smr;
    407 
    408     /* enable operations */
    409     SCSCR(uart->chn) |= SH7750_SCSCR_TE | SH7750_SCSCR_RE;
    410     rtems_interrupt_enable(level);
    411 
    412     return RTEMS_SUCCESSFUL;
     397    *smrP = (uint8_t)smr;
     398    *scrP |= SH7750_SCSCR_TE | SH7750_SCSCR_RE;    /* enable operations */
     399  } else {
     400    volatile uint16_t *scrP = (volatile uint16_t *)SH7750_SCSCR2;
     401    volatile uint16_t *smrP = (volatile uint16_t *)SH7750_SCSMR2;
     402
     403    *scrP &= ~(SH7750_SCSCR_TE | SH7750_SCSCR_RE); /* disable operations */
     404    sh4uart_set_baudrate(uart, baud);
     405    *smrP = (uint8_t)smr;
     406    *scrP |= SH7750_SCSCR_TE | SH7750_SCSCR_RE;    /* enable operations */
     407  }
     408
     409  rtems_interrupt_enable(level);
     410
     411  return RTEMS_SUCCESSFUL;
    413412}
    414413
     
    426425sh4uart_handle_error(sh4uart *uart)
    427426{
    428 #if 0
    429     int status_reg = SCSSR(uart->chn);
    430 #endif
    431 
    432     if(uart->chn == SH4_SCI)
    433     {
    434         SCSSR1 &= ~(SH7750_SCSSR1_ORER | SH7750_SCSSR1_FER | SH7750_SCSSR1_PER);
    435     }
    436     else
    437     {
    438         SCSSR2 &= ~(SH7750_SCSSR2_ER | SH7750_SCSSR2_BRK | SH7750_SCSSR2_FER);
    439         SCLSR2 &= ~(SH7750_SCLSR2_ORER);
    440     }
     427  if (uart->chn == SH4_SCI) {
     428    volatile uint8_t *scr = (volatile uint8_t *)SH7750_SCSCR1;
     429    *scr &= ~(SH7750_SCSSR1_ORER | SH7750_SCSSR1_FER | SH7750_SCSSR1_PER);
     430  } else {
     431    volatile uint16_t *scr = (volatile uint16_t *)SH7750_SCSCR2;
     432    *scr &= ~(SH7750_SCSSR2_ER | SH7750_SCSSR2_BRK | SH7750_SCSSR2_FER);
     433    *scr &= ~(SH7750_SCLSR2_ORER);
     434  }
    441435}
    442436
     
    460454sh4uart_poll_read(sh4uart *uart)
    461455{
    462     int chn = uart->chn;
    463     int error_occured = 0;
    464     int parity_error = 0;
    465     int break_occured = 0;
    466     int ch;
    467 
    468     if (uart->parerr_mark_flag == 1)
    469     {
    470         uart->parerr_mark_flag = 0;
    471         return 0;
     456  int chn = uart->chn;
     457  int error_occured = 0;
     458  int parity_error = 0;
     459  int break_occured = 0;
     460  int ch;
     461
     462  if (uart->parerr_mark_flag == 1) {
     463    uart->parerr_mark_flag = 0;
     464    return 0;
     465  }
     466
     467  if (chn == SH4_SCI) {
     468    if ((SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER |
     469                 SH7750_SCSSR1_ORER)) != 0) {
     470      error_occured = 1;
     471      if (SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER))
     472        parity_error = 1;
     473      sh4uart_handle_error(uart);
    472474    }
    473 
    474     if (chn == SH4_SCI)
    475     {
    476         if ((SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER |
    477                      SH7750_SCSSR1_ORER)) != 0)
    478         {
    479             error_occured = 1;
    480             if (SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER))
    481                 parity_error = 1;
    482             sh4uart_handle_error(uart);
    483         }
    484         if ((SCSSR1 & SH7750_SCSSR1_RDRF) == 0)
    485             return -1;
     475    if ((SCSSR1 & SH7750_SCSSR1_RDRF) == 0)
     476      return -1;
     477  } else {
     478    if ((SCSSR2 & (SH7750_SCSSR2_ER | SH7750_SCSSR2_DR |
     479                 SH7750_SCSSR2_BRK)) != 0 ||
     480            (SCLSR2 & SH7750_SCLSR2_ORER) != 0) {
     481      error_occured = 1;
     482      if (SCSSR2 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER))
     483        parity_error = 1;
     484      if (SCSSR2 & SH7750_SCSSR2_BRK)
     485        break_occured = 1;
     486      sh4uart_handle_error(uart);
    486487    }
     488    if ((SCSSR2 & SH7750_SCSSR2_RDF) == 0)
     489      return -1;
     490  }
     491
     492  if (parity_error && !(uart->c_iflag & IGNPAR)) {
     493    if (uart->c_iflag & PARMRK) {
     494      uart->parerr_mark_flag = 1;
     495      return 0xff;
     496    } else
     497      return 0;
     498  }
     499
     500  if (break_occured && !(uart->c_iflag & BRKINT)) {
     501    if (uart->c_iflag & IGNBRK)
     502      return 0;
    487503    else
    488     {
    489         if ((SCSSR2 & (SH7750_SCSSR2_ER | SH7750_SCSSR2_DR |
    490                      SH7750_SCSSR2_BRK)) != 0 ||
    491                 (SCLSR2 & SH7750_SCLSR2_ORER) != 0)
    492         {
    493             error_occured = 1;
    494             if (SCSSR2 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER))
    495                 parity_error = 1;
    496             if (SCSSR2 & SH7750_SCSSR2_BRK)
    497                 break_occured = 1;
    498             sh4uart_handle_error(uart);
    499         }
    500         if ((SCSSR2 & SH7750_SCSSR2_RDF) == 0)
    501             return -1;
    502     }
    503 
    504     if (parity_error && !(uart->c_iflag & IGNPAR))
    505     {
    506         if (uart->c_iflag & PARMRK)
    507         {
    508             uart->parerr_mark_flag = 1;
    509             return 0xff;
    510         }
    511         else
    512             return 0;
    513     }
    514 
    515     if (break_occured && !(uart->c_iflag & BRKINT))
    516     {
    517         if (uart->c_iflag & IGNBRK)
    518             return 0;
    519         else
    520             return 0;   /* XXX -- SIGINT */
    521     }
    522 
    523     ch = SCRDR(chn);
    524     if (uart->chn == SH4_SCI)
    525         SCSSR1 &= ~SH7750_SCSSR1_RDRF;
    526     else
    527         SCSSR2 &= ~SH7750_SCSSR2_RDF;
    528 
    529     return ch;
     504      return 0;   /* XXX -- SIGINT */
     505  }
     506
     507  ch = SCRDR(chn);
     508
     509  if (uart->chn == SH4_SCI) {
     510    volatile uint8_t *scr = (volatile uint8_t *)SH7750_SCSCR1;
     511    *scr &= ~SH7750_SCSSR1_RDRF;
     512  } else {
     513    volatile uint16_t *scr = (volatile uint16_t *)SH7750_SCSCR2;
     514    *scr &= ~SH7750_SCSSR2_RDF;
     515  }
     516
     517  return ch;
    530518}
    531519
     
    545533sh4uart_poll_write(sh4uart *uart, const char *buf, int len)
    546534{
    547     while (len)
    548     {
    549         if (uart->chn == SH4_SCI)
    550         {
    551             while ((SCSSR1 & SH7750_SCSSR1_TDRE) != 0)
    552             {
    553                 SCTDR1 = *buf++;
    554                 len--;
    555                 SCSSR1 &= ~SH7750_SCSSR1_TDRE;
    556             }
     535  volatile uint8_t *ssr1 = (volatile uint8_t *)SH7750_SCSSR1;
     536  volatile uint16_t *ssr2 = (volatile uint16_t *)SH7750_SCSSR2;
     537
     538  while (len) {
     539    if (uart->chn == SH4_SCI) {
     540      while ((SCSSR1 & SH7750_SCSSR1_TDRE) != 0) {
     541          SCTDR1 = *buf++;
     542          len--;
     543          *ssr1 &= ~SH7750_SCSSR1_TDRE;
     544      }
     545    } else {
     546      while ((SCSSR2 & SH7750_SCSSR2_TDFE) != 0) {
     547        int i;
     548        for (i = 0;
     549                i < 16 - TRANSMIT_TRIGGER_VALUE(SCFCR2 &
     550                    SH7750_SCFCR2_TTRG);
     551                i++) {
     552            SCTDR2 = *buf++;
     553            len--;
    557554        }
    558         else
    559         {
    560             while ((SCSSR2 & SH7750_SCSSR2_TDFE) != 0)
    561             {
    562                 int i;
    563                 for (i = 0;
    564                         i < 16 - TRANSMIT_TRIGGER_VALUE(SCFCR2 &
    565                             SH7750_SCFCR2_TTRG);
    566                         i++)
    567                 {
    568                     SCTDR2 = *buf++;
    569                     len--;
    570                 }
    571                 while ((SCSSR2 & SH7750_SCSSR2_TDFE) == 0 ||
    572                         (SCSSR2 & SH7750_SCSSR2_TEND) == 0);
    573                     SCSSR2 &= ~(SH7750_SCSSR1_TDRE | SH7750_SCSSR2_TEND);
    574             }
    575         }
     555        while ((SCSSR2 & SH7750_SCSSR2_TDFE) == 0 ||
     556                (SCSSR2 & SH7750_SCSSR2_TEND) == 0);
     557            *ssr2 &= ~(SH7750_SCSSR1_TDRE | SH7750_SCSSR2_TEND);
     558      }
    576559    }
    577     return 0;
     560  }
     561  return 0;
    578562}
    579563
     
    594578sh4uart1_interrupt_receive(rtems_vector_number vec)
    595579{
    596     register int bp = 0;
    597     char buf[32];
    598 
    599     /* Find UART descriptor from vector number */
    600     sh4uart *uart = &sh4_uarts[0];
    601 
    602     while (1)
    603     {
    604         if ((bp < sizeof(buf) - 1) && ((SCSSR1 & SH7750_SCSSR1_RDRF) != 0))
    605         {
    606             /* Receive character and handle frame/parity errors */
    607             if ((SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER |
    608                             SH7750_SCSSR1_ORER)) != 0)
    609             {
    610                 if (SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER))
    611                 {
    612                     if(!(uart->c_iflag & IGNPAR))
    613                     {
    614                         if (uart->c_iflag & PARMRK)
    615                         {
    616                             buf[bp++] = 0xff;
    617                             buf[bp++] = 0x00;
    618                         }
    619                         else
    620                             buf[bp++] = 0x00;
    621                     }
    622                     else
    623                         buf[bp++] = SCRDR1;
    624                 }
    625                 sh4uart_handle_error(uart);
    626             }
    627             else
    628                 buf[bp++] = SCRDR1;
    629             SCSSR1 &= ~SH7750_SCSSR1_RDRF;
    630         }
    631         else
    632         {
    633             if (bp != 0)
    634                 rtems_termios_enqueue_raw_characters(uart->tty, buf, bp);
    635             break;
    636         }
     580  register int bp = 0;
     581  char buf[32];
     582  volatile uint8_t *ssr1 = (volatile uint8_t *)SH7750_SCSSR1;
     583
     584
     585  /* Find UART descriptor from vector number */
     586  sh4uart *uart = &sh4_uarts[0];
     587
     588  while (1) {
     589    if ((bp < sizeof(buf) - 1) && ((SCSSR1 & SH7750_SCSSR1_RDRF) != 0)) {
     590      /* Receive character and handle frame/parity errors */
     591      if ((SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER |
     592                      SH7750_SCSSR1_ORER)) != 0) {
     593        if (SCSSR1 & (SH7750_SCSSR1_PER | SH7750_SCSSR1_FER)) {
     594            if (!(uart->c_iflag & IGNPAR)) {
     595              if (uart->c_iflag & PARMRK) {
     596                buf[bp++] = 0xff;
     597                buf[bp++] = 0x00;
     598              } else
     599                buf[bp++] = 0x00;
     600            } else
     601              buf[bp++] = SCRDR1;
     602          }
     603          sh4uart_handle_error(uart);
     604      } else
     605          buf[bp++] = SCRDR1;
     606      *ssr1 &= ~SH7750_SCSSR1_RDRF;
     607    } else {
     608      if (bp != 0)
     609        rtems_termios_enqueue_raw_characters(uart->tty, buf, bp);
     610      break;
    637611    }
     612  }
    638613}
    639614
     
    651626sh4uart2_interrupt_receive(rtems_vector_number vec)
    652627{
    653     register int bp = 0;
    654     char buf[32];
    655 
    656     /* Find UART descriptor from vector number */
    657     sh4uart *uart = &sh4_uarts[1];
    658 
    659     while (1)
    660     {
    661         if ((bp < sizeof(buf) - 1) && ((SCSSR2 & SH7750_SCSSR2_RDF) != 0))
    662         {
    663             if ((SCSSR2 & (SH7750_SCSSR2_ER | SH7750_SCSSR2_DR |
    664                             SH7750_SCSSR2_BRK)) != 0 ||
    665                     (SH7750_SCLSR2 & SH7750_SCLSR2_ORER) != 0)
    666             {
    667                 if (SCSSR2 & SH7750_SCSSR2_ER)
    668                 {
    669                     if(!(uart->c_iflag & IGNPAR))
    670                     {
    671                         if (uart->c_iflag & PARMRK)
    672                         {
    673                             buf[bp++] = 0xff;
    674                             buf[bp++] = 0x00;
    675                         }
    676                         else
    677                             buf[bp++] = 0x00;
    678                     }
    679                     else
    680                         buf[bp++] = SCRDR1;
    681                 }
    682 
    683                 if (SCSSR2 & SH7750_SCSSR2_BRK)
    684                 {
    685                     if (uart->c_iflag & IGNBRK)
    686                         buf[bp++] = 0x00;
    687                     else
    688                         buf[bp++] = 0x00;   /* XXX -- SIGINT */
    689                 }
    690 
    691                 sh4uart_handle_error(uart);
    692             }
    693             else
    694                 buf[bp++] = SCRDR1;
    695             SCSSR2 &= ~SH7750_SCSSR2_RDF;
     628  register int bp = 0;
     629  char buf[32];
     630  volatile uint16_t *ssr2 = (volatile uint16_t *)SH7750_SCSSR2;
     631
     632
     633  /* Find UART descriptor from vector number */
     634  sh4uart *uart = &sh4_uarts[1];
     635
     636  while (1) {
     637    if ((bp < sizeof(buf) - 1) && ((SCSSR2 & SH7750_SCSSR2_RDF) != 0)) {
     638      if ((SCSSR2 & (SH7750_SCSSR2_ER | SH7750_SCSSR2_DR |
     639                      SH7750_SCSSR2_BRK)) != 0 ||
     640              (SH7750_SCLSR2 & SH7750_SCLSR2_ORER) != 0) {
     641        if (SCSSR2 & SH7750_SCSSR2_ER) {
     642          if (!(uart->c_iflag & IGNPAR)) {
     643            if (uart->c_iflag & PARMRK) {
     644              buf[bp++] = 0xff;
     645              buf[bp++] = 0x00;
     646            } else
     647              buf[bp++] = 0x00;
     648          } else
     649              buf[bp++] = SCRDR1;
    696650        }
    697         else
    698         {
    699             if (bp != 0)
    700                 rtems_termios_enqueue_raw_characters(uart->tty, buf, bp);
    701             break;
     651
     652        if (SCSSR2 & SH7750_SCSSR2_BRK) {
     653          if (uart->c_iflag & IGNBRK)
     654            buf[bp++] = 0x00;
     655          else
     656            buf[bp++] = 0x00;   /* XXX -- SIGINT */
    702657        }
     658
     659        sh4uart_handle_error(uart);
     660      } else
     661        buf[bp++] = SCRDR1;
     662      *ssr2 &= ~SH7750_SCSSR2_RDF;
     663    } else {
     664      if (bp != 0)
     665        rtems_termios_enqueue_raw_characters(uart->tty, buf, bp);
     666      break;
    703667    }
     668  }
    704669}
    705670
     
    718683sh4uart1_interrupt_transmit(rtems_vector_number vec)
    719684{
    720     /* Find UART descriptor from vector number */
    721     sh4uart *uart = &sh4_uarts[0];
    722 
    723     if (uart->tx_buf != NULL && uart->tx_ptr < uart->tx_buf_len)
    724     {
    725         while ((SCSSR1 & SH7750_SCSSR1_TDRE) != 0 &&
    726                 uart->tx_ptr < uart->tx_buf_len)
    727         {
    728             SCTDR1 = uart->tx_buf[uart->tx_ptr++];
    729             SCSSR1 &= ~SH7750_SCSSR1_TDRE;
    730         }
     685  volatile uint8_t *scr1 = (volatile uint8_t *)SH7750_SCSCR1;
     686  volatile uint8_t *ssr1 = (volatile uint8_t *)SH7750_SCSSR1;
     687
     688  /* Find UART descriptor from vector number */
     689  sh4uart *uart = &sh4_uarts[0];
     690
     691  if (uart->tx_buf != NULL && uart->tx_ptr < uart->tx_buf_len) {
     692    while ((SCSSR1 & SH7750_SCSSR1_TDRE) != 0 &&
     693            uart->tx_ptr < uart->tx_buf_len) {
     694        SCTDR1 = uart->tx_buf[uart->tx_ptr++];
     695        *ssr1 &= ~SH7750_SCSSR1_TDRE;
    731696    }
    732     else
    733     {
    734         register int dequeue = uart->tx_buf_len;
    735 
    736         uart->tx_buf = NULL;
    737         uart->tx_ptr = uart->tx_buf_len = 0;
    738 
    739         /* Disable interrupts while we do not have any data to transmit */
    740         SCSCR1 &= ~SH7750_SCSCR_TIE;
    741 
    742         rtems_termios_dequeue_characters(uart->tty, dequeue);
    743     }
     697  } else {
     698    register int dequeue = uart->tx_buf_len;
     699
     700    uart->tx_buf = NULL;
     701    uart->tx_ptr = uart->tx_buf_len = 0;
     702
     703    /* Disable interrupts while we do not have any data to transmit */
     704    *scr1 &= ~SH7750_SCSCR_TIE;
     705
     706    rtems_termios_dequeue_characters(uart->tty, dequeue);
     707  }
    744708}
    745709
     
    757721sh4uart2_interrupt_transmit(rtems_vector_number vec)
    758722{
    759     /* Find UART descriptor from vector number */
    760     sh4uart *uart = &sh4_uarts[1];
    761 
    762     if (uart->tx_buf != NULL && uart->tx_ptr < uart->tx_buf_len)
    763     {
    764             while ((SCSSR2 & SH7750_SCSSR2_TDFE) != 0)
    765             {
    766                 int i;
    767                 for (i = 0;
    768                         i < 16 - TRANSMIT_TRIGGER_VALUE(SCFCR2 &
    769                             SH7750_SCFCR2_TTRG);
    770                         i++)
    771                     SCTDR2 = uart->tx_buf[uart->tx_ptr++];
    772                 while ((SCSSR1 & SH7750_SCSSR1_TDRE) == 0 ||
    773                         (SCSSR1 & SH7750_SCSSR1_TEND) == 0);
    774                     SCSSR1 &= ~(SH7750_SCSSR1_TDRE | SH7750_SCSSR2_TEND);
    775             }
     723  volatile uint8_t *ssr1 = (volatile uint8_t *)SH7750_SCSSR1;
     724  volatile uint16_t *scr2 = (volatile uint16_t *)SH7750_SCSCR2;
     725
     726  /* Find UART descriptor from vector number */
     727  sh4uart *uart = &sh4_uarts[1];
     728
     729  if (uart->tx_buf != NULL && uart->tx_ptr < uart->tx_buf_len) {
     730    while ((SCSSR2 & SH7750_SCSSR2_TDFE) != 0) {
     731        int i;
     732        for (i = 0;
     733             i < 16 - TRANSMIT_TRIGGER_VALUE(SCFCR2 & SH7750_SCFCR2_TTRG);
     734             i++)
     735          SCTDR2 = uart->tx_buf[uart->tx_ptr++];
     736        while ((SCSSR1 & SH7750_SCSSR1_TDRE) == 0 ||
     737                (SCSSR1 & SH7750_SCSSR1_TEND) == 0);
     738        *ssr1 &= ~(SH7750_SCSSR1_TDRE | SH7750_SCSSR2_TEND);
    776739    }
    777     else
    778     {
    779         register int dequeue = uart->tx_buf_len;
    780 
    781         uart->tx_buf = NULL;
    782         uart->tx_ptr = uart->tx_buf_len = 0;
    783 
    784         /* Disable interrupts while we do not have any data to transmit */
    785         SCSCR2 &= ~SH7750_SCSCR_TIE;
    786 
    787         rtems_termios_dequeue_characters(uart->tty, dequeue);
    788     }
     740  } else {
     741    register int dequeue = uart->tx_buf_len;
     742
     743    uart->tx_buf = NULL;
     744    uart->tx_ptr = uart->tx_buf_len = 0;
     745
     746    /* Disable interrupts while we do not have any data to transmit */
     747    *scr2 &= ~SH7750_SCSCR_TIE;
     748
     749    rtems_termios_dequeue_characters(uart->tty, dequeue);
     750  }
    789751}
    790752
     
    803765sh4uart_interrupt_write(sh4uart *uart, const char *buf, int len)
    804766{
    805     int level;
    806 
    807     while ((SCSSR1 & SH7750_SCSSR1_TEND) == 0);
    808 
    809     rtems_interrupt_disable(level);
    810 
    811     uart->tx_buf = buf;
    812     uart->tx_buf_len = len;
    813     uart->tx_ptr = 0;
    814 
    815     if (uart->chn == SH4_SCI)
    816     {
    817         SCSCR1 |= SH7750_SCSCR_TIE;
    818     }
    819     else
    820         SCSCR2 |= SH7750_SCSCR_TIE;
    821 
    822     rtems_interrupt_enable(level);
    823 
    824     return RTEMS_SUCCESSFUL;
     767  volatile uint8_t  *scr1 = (volatile uint8_t *)SH7750_SCSCR1;
     768  volatile uint16_t *scr2 = (volatile uint16_t *)SH7750_SCSCR2;
     769  int level;
     770
     771  while ((SCSSR1 & SH7750_SCSSR1_TEND) == 0);
     772
     773  rtems_interrupt_disable(level);
     774
     775  uart->tx_buf = buf;
     776  uart->tx_buf_len = len;
     777  uart->tx_ptr = 0;
     778
     779  if (uart->chn == SH4_SCI)
     780    *scr1 |= SH7750_SCSCR_TIE;
     781  else
     782    *scr2 |= SH7750_SCSCR_TIE;
     783
     784  rtems_interrupt_enable(level);
     785
     786  return RTEMS_SUCCESSFUL;
    825787}
    826788
     
    837799sh4uart_stop_remote_tx(sh4uart *uart)
    838800{
    839     SCSCR(uart->chn) &= ~(SH7750_SCSCR_RIE | SH7750_SCSCR_RE);
    840     return RTEMS_SUCCESSFUL;
     801  if ( uart->chn == 1 ) {
     802    volatile uint8_t *scr = (volatile uint8_t *)SH7750_SCSCR1;
     803    *scr &= ~(SH7750_SCSCR_RIE | SH7750_SCSCR_RE);
     804  } else {
     805    volatile uint16_t *scr = (volatile uint16_t *)SH7750_SCSCR2;
     806    *scr &= ~(SH7750_SCSCR_RIE | SH7750_SCSCR_RE);
     807  }
     808
     809  return RTEMS_SUCCESSFUL;
    841810}
    842811
     
    853822sh4uart_start_remote_tx(sh4uart *uart)
    854823{
    855     SCSCR(uart->chn) |= SH7750_SCSCR_RIE | SH7750_SCSCR_RE;
    856     return RTEMS_SUCCESSFUL;
     824  if ( uart->chn == 1 ) {
     825    volatile uint8_t *scr = (volatile uint8_t *)SH7750_SCSCR1;
     826    *scr |= SH7750_SCSCR_RIE | SH7750_SCSCR_RE;
     827  } else {
     828    volatile uint16_t *scr = (volatile uint16_t *)SH7750_SCSCR2;
     829    *scr |= SH7750_SCSCR_RIE | SH7750_SCSCR_RE;
     830  }
     831
     832  return RTEMS_SUCCESSFUL;
    857833}
    858834
     
    932908ipl_console_poll_write(int minor, const char *buf, int len)
    933909{
    934     int c;
    935     while (len > 0)
    936     {
    937         c = (len < 64 ? len : 64);
    938         ipl_serial_output(buf, c);
    939         len -= c;
    940         buf += c;
    941     }
    942     return 0;
     910  int c;
     911  while (len > 0) {
     912    c = (len < 64 ? len : 64);
     913    ipl_serial_output(buf, c);
     914    len -= c;
     915    buf += c;
     916  }
     917  return 0;
    943918}
    944919#endif
Note: See TracChangeset for help on using the changeset viewer.