Changeset ab2dbd7 in rtems for c/src/libchip/serial/mc68681.c


Ignore:
Timestamp:
Jun 22, 1998, 11:09:32 AM (22 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
7deeb16
Parents:
36152b0e
Message:

Added mc68681 stuff to the makefile.

Added numerous constants to mc68681_p.h.

Changed spacing.

At this point the polled support is in but nothing else is right except the
structure.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • c/src/libchip/serial/mc68681.c

    r36152b0e rab2dbd7  
    2525#include <libchip/serial.h>
    2626#include "mc68681_p.h"
     27#include "mc68681.h"
    2728
    2829/*
     
    6970
    7071/*
    71  *  Types for get and set register routines
    72  */
    73 
    74 typedef unsigned8 (*getRegister_f)(unsigned32 port, unsigned8 register);
    75 typedef void      (*setRegister_f)(
    76                             unsigned32 port, unsigned8 reg, unsigned8 value);
    77 /*
    7872 *  Console Device Driver Entry Points
    7973 */
     
    8276{
    8377  /*
    84    * If the configuration dependant probe has located the device then
     78   * If the configuration dependent probe has located the device then
    8579   * assume it is there
    8680   */
     
    9084static void mc68681_init(int minor)
    9185{
     86/* XXX */
    9287  unsigned32              pMC68681;
    9388  unsigned8               ucTrash;
    9489  unsigned8               ucDataByte;
    9590  unsigned32              ulBaudDivisor;
    96   mc68681_context        *pns68681Context;
     91  mc68681_context        *pmc68681Context;
    9792  setRegister_f           setReg;
    9893  getRegister_f           getReg;
    9994
    100   pmc68681Context=(ns68681_context *)malloc(sizeof(mc68681_context));
    101 
    102   Console_Port_Data[minor].pDeviceContext=(void *)pmc68681Context;
    103   pmc68681Context->ucModemCtrl=SP_MODEM_IRQ;
     95#if 1
     96ulBaudDivisor = ucDataByte = ucTrash =  0;
     97#endif
     98  pmc68681Context = (mc68681_context *) malloc(sizeof(mc68681_context));
     99
     100  Console_Port_Data[minor].pDeviceContext = (void *)pmc68681Context;
     101#if 0
     102  pmc68681Context->ucModemCtrl = SP_MODEM_IRQ;
     103#endif
    104104
    105105  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
     
    107107  getReg   = Console_Port_Tbl[minor].getRegister;
    108108
     109#if 0
    109110  /* Clear the divisor latch, clear all interrupt enables,
    110111   * and reset and
     
    112113   */
    113114
    114   (*setReg)(pMC68681, NS68681_LINE_CONTROL, 0x0);
    115   (*setReg)(pMC68681, NS68681_INTERRUPT_ENABLE, 0x0);
     115  (*setReg)(pMC68681, MC68681_LINE_CONTROL, 0x0);
     116  (*setReg)(pMC68681, MC68681_INTERRUPT_ENABLE, 0x0);
    116117
    117118  /* Set the divisor latch and set the baud rate. */
     
    119120  ulBaudDivisor=MC68681_Baud((unsigned32)Console_Port_Tbl[minor].pDeviceParams);
    120121  ucDataByte = SP_LINE_DLAB;
    121   (*setReg)(pMC68681, NS68681_LINE_CONTROL, ucDataByte);
    122   (*setReg)(pMC68681, NS68681_TRANSMIT_BUFFER, ulBaudDivisor&0xff);
    123   (*setReg)(pMC68681, NS68681_INTERRUPT_ENABLE, (ulBaudDivisor>>8)&0xff);
     122  (*setReg)(pMC68681, MC68681_LINE_CONTROL, ucDataByte);
     123  (*setReg)(pMC68681, MC68681_TRANSMIT_BUFFER, ulBaudDivisor&0xff);
     124  (*setReg)(pMC68681, MC68681_INTERRUPT_ENABLE, (ulBaudDivisor>>8)&0xff);
    124125
    125126  /* Clear the divisor latch and set the character size to eight bits */
    126127  /* with one stop bit and no parity checking. */
    127128  ucDataByte = EIGHT_BITS;
    128   (*setReg)(pMC68681, NS68681_LINE_CONTROL, ucDataByte);
     129  (*setReg)(pMC68681, MC68681_LINE_CONTROL, ucDataByte);
    129130
    130131  /* Enable and reset transmit and receive FIFOs. TJA     */
    131132  ucDataByte = SP_FIFO_ENABLE;
    132   (*setReg)(pMC68681, NS68681_FIFO_CONTROL, ucDataByte);
     133  (*setReg)(pMC68681, MC68681_FIFO_CONTROL, ucDataByte);
    133134
    134135  ucDataByte = SP_FIFO_ENABLE | SP_FIFO_RXRST | SP_FIFO_TXRST;
    135   (*setReg)(pMC68681, NS68681_FIFO_CONTROL, ucDataByte);
     136  (*setReg)(pMC68681, MC68681_FIFO_CONTROL, ucDataByte);
    136137
    137138  /*
     
    139140   */
    140141  ucDataByte = 0;
    141   (*setReg)(pMC68681, NS68681_INTERRUPT_ENABLE, ucDataByte);
     142  (*setReg)(pMC68681, MC68681_INTERRUPT_ENABLE, ucDataByte);
    142143
    143144  /* Set data terminal ready. */
    144145  /* And open interrupt tristate line */
    145   (*setReg)(pMC68681, NS68681_MODEM_CONTROL,pmc68681Context->ucModemCtrl);
    146 
    147   ucTrash = (*getReg)(pMC68681, NS68681_LINE_STATUS );
    148   ucTrash = (*getReg)(pMC68681, NS68681_RECEIVE_BUFFER );
     146  (*setReg)(pMC68681, MC68681_MODEM_CONTROL,pmc68681Context->ucModemCtrl);
     147
     148  ucTrash = (*getReg)(pMC68681, MC68681_LINE_STATUS );
     149  ucTrash = (*getReg)(pMC68681, MC68681_RECEIVE_BUFFER );
     150#endif
    149151}
    150152
     
    155157)
    156158{
     159/* XXX */
    157160  /*
    158161   * Assert DTR
     
    172175)
    173176{
     177/* XXX */
    174178  /*
    175179   * Negate DTR
     
    195199  int                     iTimeout;
    196200  getRegister_f           getReg;
    197   setRegister_f           setReg;
     201  setData_f               setData;
    198202
    199203  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
    200204  getReg   = Console_Port_Tbl[minor].getRegister;
    201   setReg   = Console_Port_Tbl[minor].setRegister;
     205  setData  = Console_Port_Tbl[minor].setData;
    202206
    203207  /*
    204208   * wait for transmitter holding register to be empty
    205209   */
    206   iTimeout=1000;
    207   ucLineStatus = (*getReg)(pMC68681, NS68681_LINE_STATUS);
    208   while ((ucLineStatus & SP_LSR_THOLD) == 0) {
     210  iTimeout = 1000;
     211  ucLineStatus = (*getReg)(pMC68681, MC68681_STATUS_REG);
     212  while ((ucLineStatus & MC68681_TX_READY) == 0) {
     213
    209214    /*
    210215     * Yield while we wait
    211216     */
     217
    212218     if(_System_state_Is_up(_System_state_Get())) {
    213219       rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
    214220     }
    215      ucLineStatus = (*getReg)(pMC68681, NS68681_LINE_STATUS);
     221     ucLineStatus = (*getReg)(pMC68681, MC68681_STATUS_REG);
    216222     if(!--iTimeout) {
    217223       break;
     
    222228   * transmit character
    223229   */
    224   (*setReg)(pMC68681, NS68681_TRANSMIT_BUFFER, cChar);
     230
     231  (*setData)(pMC68681, cChar);
    225232}
    226233
     
    228235 * These routines provide control of the RTS and DTR lines
    229236 */
     237
    230238/*
    231239 *  mc68681_assert_RTS
    232240 */
     241
    233242static int mc68681_assert_RTS(int minor)
    234243{
     244/* XXX */
     245
    235246  unsigned32              pMC68681;
    236247  unsigned32              Irql;
    237   mc68681_context        *pns68681Context;
     248  mc68681_context        *pmc68681Context;
    238249  setRegister_f           setReg;
    239250
    240   pmc68681Context=(ns68681_context *) Console_Port_Data[minor].pDeviceContext;
     251
     252  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
    241253
    242254  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
     
    247259   */
    248260  rtems_interrupt_disable(Irql);
    249   pmc68681Context->ucModemCtrl|=SP_MODEM_RTS;
    250   (*setReg)(pMC68681, NS68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
     261#if 0
     262  pmc68681Context->ucModemCtrl |= SP_MODEM_RTS;
     263  (*setReg)(pMC68681, MC68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
     264#endif
    251265  rtems_interrupt_enable(Irql);
    252266  return 0;
     
    258272static int mc68681_negate_RTS(int minor)
    259273{
     274/* XXX */
    260275  unsigned32              pMC68681;
    261276  unsigned32              Irql;
    262   mc68681_context        *pns68681Context;
     277  mc68681_context        *pmc68681Context;
    263278  setRegister_f           setReg;
    264279
    265   pmc68681Context=(ns68681_context *) Console_Port_Data[minor].pDeviceContext;
     280  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
    266281
    267282  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
     
    272287   */
    273288  rtems_interrupt_disable(Irql);
    274   pmc68681Context->ucModemCtrl&=~SP_MODEM_RTS;
    275   (*setReg)(pMC68681, NS68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
     289#if 0
     290  pmc68681Context->ucModemCtrl &= ~SP_MODEM_RTS;
     291  (*setReg)(pMC68681, MC68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
     292#endif
    276293  rtems_interrupt_enable(Irql);
    277294  return 0;
     
    282299 * line to the remote CTS line
    283300 */
     301
    284302/*
    285303 *  mc68681_assert_DTR
    286304 */
     305
    287306static int mc68681_assert_DTR(int minor)
    288307{
     308/* XXX */
    289309  unsigned32              pMC68681;
    290310  unsigned32              Irql;
    291   mc68681_context        *pns68681Context;
     311  mc68681_context        *pmc68681Context;
    292312  setRegister_f           setReg;
    293313
    294   pmc68681Context=(ns68681_context *) Console_Port_Data[minor].pDeviceContext;
     314  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
    295315
    296316  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
     
    301321   */
    302322  rtems_interrupt_disable(Irql);
    303   pmc68681Context->ucModemCtrl|=SP_MODEM_DTR;
    304   (*setReg)(pMC68681, NS68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
     323#if 0
     324  pmc68681Context->ucModemCtrl |= SP_MODEM_DTR;
     325  (*setReg)(pMC68681, MC68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
     326#endif
    305327  rtems_interrupt_enable(Irql);
    306328  return 0;
     
    310332 *  mc68681_negate_DTR
    311333 */
     334
    312335static int mc68681_negate_DTR(int minor)
    313336{
     337/* XXX */
    314338  unsigned32              pMC68681;
    315339  unsigned32              Irql;
    316   mc68681_context        *pns68681Context;
     340  mc68681_context        *pmc68681Context;
    317341  setRegister_f           setReg;
    318342
    319   pmc68681Context=(ns68681_context *) Console_Port_Data[minor].pDeviceContext;
     343  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
    320344
    321345  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
     
    326350   */
    327351  rtems_interrupt_disable(Irql);
    328   pmc68681Context->ucModemCtrl&=~SP_MODEM_DTR;
    329   (*setReg)(pMC68681, NS68681_MODEM_CONTROL,pmc68681Context->ucModemCtrl);
     352#if 0
     353  pmc68681Context->ucModemCtrl &= ~SP_MODEM_DTR;
     354  (*setReg)(pMC68681, MC68681_MODEM_CONTROL,pmc68681Context->ucModemCtrl);
     355#endif
    330356  rtems_interrupt_enable(Irql);
    331357  return 0;
     
    335361 *  mc68681_isr
    336362 *
    337  *  This routine is the console interrupt handler for COM1 and COM2
     363 *  This routine is the console interrupt handler.
    338364 *
    339365 *  Input parameters:
     
    349375)
    350376{
     377/* XXX */
    351378  unsigned32              pMC68681;
    352379  volatile unsigned8      ucLineStatus;
     
    356383  setRegister_f           setReg;
    357384
     385#if 1
     386cChar = ucInterruptId = ucLineStatus = 0;
     387#endif
    358388  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
    359389  getReg   = Console_Port_Tbl[minor].getRegister;
    360390  setReg   = Console_Port_Tbl[minor].setRegister;
    361391
     392#if 0
    362393  do {
    363394    /*
     
    365396     */
    366397    while(TRUE) {
    367       ucLineStatus = (*getReg)(pMC68681, NS68681_LINE_STATUS);
     398      ucLineStatus = (*getReg)(pMC68681, MC68681_LINE_STATUS);
    368399      if(~ucLineStatus & SP_LSR_RDY) {
    369400        break;
    370401      }
    371       cChar = (*getReg)(pMC68681, NS68681_RECEIVE_BUFFER);
     402      cChar = (*getReg)(pMC68681, MC68681_RECEIVE_BUFFER);
    372403      rtems_termios_enqueue_raw_characters(
    373404        Console_Port_Data[minor].termios_data,
     
    379410    while(TRUE) {
    380411      if(Ring_buffer_Is_empty(&Console_Port_Data[minor].TxBuffer)) {
    381         Console_Port_Data[minor].bActive=FALSE;
    382         if(Console_Port_Tbl[minor].pDeviceFlow !=&mc68681_flow_RTSCTS) {
     412        Console_Port_Data[minor].bActive = FALSE;
     413        if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_RTSCTS) {
    383414          mc68681_negate_RTS(minor);
    384415        }
     
    390421      }
    391422
    392       ucLineStatus = (*getReg)(pMC68681, NS68681_LINE_STATUS);
     423      ucLineStatus = (*getReg)(pMC68681, MC68681_LINE_STATUS);
    393424      if(~ucLineStatus & SP_LSR_THOLD) {
    394425        /*
     
    404435       * transmit character
    405436       */
    406       (*setReg)(pMC68681, NS68681_TRANSMIT_BUFFER, cChar);
     437      (*setReg)(pMC68681, MC68681_TRANSMIT_BUFFER, cChar);
    407438    }
    408439
    409     ucInterruptId = (*getReg)(pMC68681, NS68681_INTERRUPT_ID);
    410   }
    411   while((ucInterruptId&0xf)!=0x1);
     440    ucInterruptId = (*getReg)(pMC68681, MC68681_INTERRUPT_ID);
     441  }
     442  while((ucInterruptId&0xf) != 0x1);
     443#endif
    412444}
    413445
     
    418450  int     minor;
    419451
    420   for(minor=0;minor<Console_Port_Count;minor++) {
    421     if(vector==Console_Port_Tbl[minor].ulIntVector) {
     452  for(minor=0 ; minor<Console_Port_Count ; minor++) {
     453    if(vector == Console_Port_Tbl[minor].ulIntVector) {
    422454      mc68681_process(minor);
    423455    }
     
    428460 *  mc68681_flush
    429461 */
     462
    430463static int mc68681_flush(int major, int minor, void *arg)
    431464{
     
    461494)
    462495{
     496/* XXX */
    463497  unsigned32            pMC68681;
    464498  unsigned8             ucDataByte;
    465   setRegister_f           setReg;
    466 
     499  setRegister_f         setReg;
     500
     501#if 1
     502ucDataByte = 0;
     503#endif
    467504  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
    468505  setReg   = Console_Port_Tbl[minor].setRegister;
    469506
     507#if 0
    470508  /*
    471509   * Enable interrupts
    472510   */
    473511  ucDataByte = SP_INT_RX_ENABLE | SP_INT_TX_ENABLE;
    474   (*setReg)(pMC68681, NS68681_INTERRUPT_ENABLE, ucDataByte);
    475 
     512  (*setReg)(pMC68681, MC68681_INTERRUPT_ENABLE, ucDataByte);
     513#endif
    476514}
    477515
     
    493531 *
    494532 *  Console Termios output entry point.
    495  *
    496  */
     533 */
     534
    497535static int mc68681_write_support_int(
    498536  int   minor,
     
    504542  unsigned32 Irql;
    505543
    506   for(i=0; i<len;) {
     544  for(i=0 ; i<len ;) {
    507545    if(Ring_buffer_Is_full(&Console_Port_Data[minor].TxBuffer)) {
    508546      if(!Console_Port_Data[minor].bActive) {
     
    538576   * Ensure that characters are on the way
    539577   */
     578
    540579  if(!Console_Port_Data[minor].bActive) {
    541580    /*
     
    544583    rtems_interrupt_disable(Irql);
    545584    Console_Port_Data[minor].bActive = TRUE;
    546     if(Console_Port_Tbl[minor].pDeviceFlow !=&mc68681_flow_RTSCTS) {
     585    if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_RTSCTS) {
    547586      mc68681_assert_RTS(minor);
    548587    }
     
    560599 *
    561600 */
     601
    562602static int mc68681_write_support_polled(
    563603  int         minor,
     
    599639  char                 cChar;
    600640  getRegister_f        getReg;
     641  getData_f            getData;
    601642
    602643  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
    603644  getReg   = Console_Port_Tbl[minor].getRegister;
    604 
    605   ucLineStatus = (*getReg)(pMC68681, NS68681_LINE_STATUS);
    606   if(ucLineStatus & SP_LSR_RDY) {
    607     cChar = (*getReg)(pMC68681, NS68681_RECEIVE_BUFFER);
    608     return((int)cChar);
     645  getData  = Console_Port_Tbl[minor].getData;
     646
     647  ucLineStatus = (*getReg)(pMC68681, MC68681_STATUS_REG);
     648  if(ucLineStatus & MC68681_RX_READY) {
     649    cChar = (*getData)(pMC68681);
     650    return (int)cChar;
    609651  } else {
    610652    return(-1);
Note: See TracChangeset for help on using the changeset viewer.