LXR 6.1/​bsps/​m68k/​av5282/​console/​console.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:23:44

 /*
  *  Multi UART console serial I/O.
  *
  *  TO DO: Add DMA input/output
  */
 
 #include <stdio.h>
 #include <fcntl.h>
 #include <termios.h>
 #include <bsp.h>
 #include <malloc.h>
 
 #include <rtems/bspIo.h>
 #include <rtems/console.h>
 #include <rtems/libio.h>
 #include <rtems/termiostypes.h>
 
 #define UART_INTC0_IRQ_VECTOR(x) (64+13+(x))
 
 #define MCF5282_UART_USR_ERROR ( MCF5282_UART_USR_RB | \
                                  MCF5282_UART_USR_FE | \
                                  MCF5282_UART_USR_PE | \
                                  MCF5282_UART_USR_OE )
 
 static ssize_t IntUartPollWrite(int minor, const char *buf, size_t len);
 static ssize_t IntUartInterruptWrite (int minor, const char *buf, size_t len);
 
 static void _BSP_null_char( char c )
 {
   rtems_interrupt_level level;
 
   rtems_interrupt_disable(level);
   while ( (MCF5282_UART_USR(CONSOLE_PORT) & MCF5282_UART_USR_TXRDY) == 0 )
     continue;
 
   MCF5282_UART_UTB(CONSOLE_PORT) = c;
   while ( (MCF5282_UART_USR(CONSOLE_PORT) & MCF5282_UART_USR_TXRDY) == 0 )
     continue;
 
   rtems_interrupt_enable(level);
 }
 BSP_output_char_function_type     BSP_output_char = _BSP_null_char;
 BSP_polling_getchar_function_type BSP_poll_char = NULL;
 
 #define MAX_UART_INFO     3
 #define RX_BUFFER_SIZE    512
 
 struct IntUartInfoStruct
 {
   int           iomode;
   volatile int  uimr;
   int           baud;
   int           databits;
   int           parity;
   int           stopbits;
   int           hwflow;
   int           rx_in;
   int           rx_out;
   char          rx_buffer[RX_BUFFER_SIZE];
   void         *ttyp;
 };
 
 struct IntUartInfoStruct IntUartInfo[MAX_UART_INFO];
 
 /*
  * Function : IntUartSet
  *
  * Description : This updates the hardware UART settings.
  */
 static void IntUartSet(
   int minor,
   int baud,
   int databits,
   int parity,
   int stopbits,
   int hwflow
 )
 {
   int                       divisor;
   uint32_t                  clock_speed;
   uint8_t                   umr1 = 0;
   uint8_t                   umr2 = 0;
   struct IntUartInfoStruct *info = &IntUartInfo[minor];
   rtems_interrupt_level     level;
 
   rtems_interrupt_disable(level);
 
   /* disable interrupts, clear RTS line, and disable the UARTS */
   MCF5282_UART_UIMR(minor) = 0;
   MCF5282_UART_UOP0(minor) = 1;
   MCF5282_UART_UCR(minor) =
     (MCF5282_UART_UCR_TX_DISABLED | MCF5282_UART_UCR_RX_DISABLED);
 
   /* save the current values */
   info->uimr     = 0;
   info->baud     = baud;
   info->databits = databits;
   info->parity   = parity;
   info->stopbits = stopbits;
   info->hwflow   = hwflow;
 
   clock_speed = get_CPU_clock_speed();
   /* determine the baud divisor value */
   divisor = (clock_speed / ( 32 * baud ));
   if ( divisor < 2 )
     divisor = 2;
 
   /* check to see if doing hardware flow control */
   if ( hwflow ) {
     /* set hardware flow options */
     umr1 |= MCF5282_UART_UMR1_RXRTS;
     umr2 |= MCF5282_UART_UMR2_TXCTS;
   }
 
   /* determine the new umr values */
   umr1 |= (parity | databits);
   umr2 |= (stopbits);
 
   /* reset the uart */
   MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_ERROR;
   MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_RX;
   MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_TX;
 
   /* reset the uart mode register and update values */
   MCF5282_UART_UCR(minor) = MCF5282_UART_UCR_RESET_MR;
   MCF5282_UART_UMR(minor) = umr1;
   MCF5282_UART_UMR(minor) = umr2;
 
   /* set the baud rate values */
   MCF5282_UART_UCSR(minor) =
     (MCF5282_UART_UCSR_RCS_SYS_CLK | MCF5282_UART_UCSR_TCS_SYS_CLK);
   MCF5282_UART_UBG1(minor) = (divisor & 0xff00) >> 8;
   MCF5282_UART_UBG2(minor) = (divisor & 0x00ff);
 
   /* enable the uart */
   MCF5282_UART_UCR(minor) =
     (MCF5282_UART_UCR_TX_ENABLED | MCF5282_UART_UCR_RX_ENABLED);
 
   /* check to see if interrupts need to be enabled */
   if ( info->iomode != TERMIOS_POLLED ) {
     /* enable rx interrupts */
     info->uimr |= MCF5282_UART_UIMR_FFULL;
     MCF5282_UART_UIMR(minor) = info->uimr;
   }
 
   /* check to see if doing hardware flow control */
   if ( hwflow ) {
     /* assert the RTS line */
     MCF5282_UART_UOP1(minor) = 1;
   }
 
   rtems_interrupt_enable(level);
 }
 
 /*
  * Function : IntUartSetAttributes
  *
  * Description : This provides the hardware-dependent portion of tcsetattr().
  * value and sets it. At the moment this just sets the baud rate.
  *
  * Note: The highest baudrate is 115200 as this stays within
  * an error of +/- 5% at 25MHz processor clock
  */
 static int IntUartSetAttributes(
   int                   minor,
   const struct termios *t
 )
 {
   /* set default index values */
   int                         baud     = (int)19200;
   int                         databits = (int)MCF5282_UART_UMR1_BC_8;
   int                         parity   = (int)MCF5282_UART_UMR1_PM_NONE;
   int                         stopbits = (int)MCF5282_UART_UMR2_STOP_BITS_1;
   int                         hwflow   = (int)0;
   struct IntUartInfoStruct   *info     = &IntUartInfo[minor];
 
   /* check to see if input is valid */
   if ( t != (const struct termios *)0 ) {
     /* determine baud rate index */
     baud = rtems_termios_baud_to_number(t->c_ospeed);
 
     /* determine data bits */
     switch ( t->c_cflag & CSIZE ) {
       case CS5:
         databits = (int)MCF5282_UART_UMR1_BC_5;
         break;
       case CS6:
         databits = (int)MCF5282_UART_UMR1_BC_6;
         break;
       case CS7:
         databits = (int)MCF5282_UART_UMR1_BC_7;
         break;
       case CS8:
         databits = (int)MCF5282_UART_UMR1_BC_8;
         break;
     }
 
     /* determine if parity is enabled */
     if ( t->c_cflag & PARENB ) {
       if ( t->c_cflag & PARODD ) {
         /* odd parity */
         parity = (int)MCF5282_UART_UMR1_PM_ODD;
       } else {
         /* even parity */
         parity = (int)MCF5282_UART_UMR1_PM_EVEN;
       }
     }
 
     /* determine stop bits */
     if ( t->c_cflag & CSTOPB ) {
       /* two stop bits */
       stopbits = (int)MCF5282_UART_UMR2_STOP_BITS_2;
     }
 
     /* check to see if hardware flow control */
     if ( t->c_cflag & CRTSCTS ) {
       hwflow = 1;
     }
   }
 
   /* check to see if values have changed */
   if ( ( baud     != info->baud     ) ||
      ( databits != info->databits ) ||
      ( parity   != info->parity   ) ||
      ( stopbits != info->stopbits ) ||
      ( hwflow   != info->hwflow   ) ) {
 
     /* call function to set values */
     IntUartSet(minor, baud, databits, parity, stopbits, hwflow);
   }
 
   return RTEMS_SUCCESSFUL;
 }
 
 /*
  * Function : IntUartInterruptHandler
  *
  * Description : This is the interrupt handler for the internal uart. It
  * determines which channel caused the interrupt before queueing any received
  * chars and dequeueing chars waiting for transmission.
  */
 static rtems_isr IntUartInterruptHandler(rtems_vector_number v)
 {
   unsigned int                chan = v - UART_INTC0_IRQ_VECTOR(0);
   struct IntUartInfoStruct   *info = &IntUartInfo[chan];
 
   /* check to see if received data */
   if ( MCF5282_UART_UISR(chan) & MCF5282_UART_UISR_RXRDY ) {
     /* read data and put into the receive buffer */
     while ( MCF5282_UART_USR(chan) & MCF5282_UART_USR_RXRDY ) {
 
       if ( MCF5282_UART_USR(chan) & MCF5282_UART_USR_ERROR ) {
         /* clear the error */
         MCF5282_UART_UCR(chan) = MCF5282_UART_UCR_RESET_ERROR;
       }
       /* put data in rx buffer and check for errors */
       info->rx_buffer[info->rx_in] = MCF5282_UART_URB(chan);
 
       /* update buffer values */
       info->rx_in++;
 
       if ( info->rx_in >= RX_BUFFER_SIZE ) {
         info->rx_in = 0;
       }
     }
 
     /* Make sure the port has been opened */
     if ( info->ttyp ) {
 
       /* check to see if task driven */
       if ( info->iomode == TERMIOS_TASK_DRIVEN ) {
         /* notify rx task that rx buffer has data */
         rtems_termios_rxirq_occured(info->ttyp);
       } else {
         /* Push up the received data */
         rtems_termios_enqueue_raw_characters(
             info->ttyp, info->rx_buffer, info->rx_in);
         info->rx_in    = 0;
       }
     }
   }
 
   /* check to see if data needs to be transmitted */
   if ( ( info->uimr & MCF5282_UART_UIMR_TXRDY ) &&
      ( MCF5282_UART_UISR(chan) & MCF5282_UART_UISR_TXRDY ) )
   {
 
     /* disable tx interrupts */
     info->uimr &= ~MCF5282_UART_UIMR_TXRDY;
     MCF5282_UART_UIMR(chan) = info->uimr;
 
     /* tell upper level that character has been sent */
     if ( info->ttyp )
       rtems_termios_dequeue_characters(info->ttyp, 1);
   }
 }
 
 /*
  * Function : IntUartInitialize
  *
  * Description : This initialises the internal uart hardware for all
  * internal uarts. If the internal uart is to be interrupt driven then the
  * interrupt vectors are hooked.
  */
 static void IntUartInitialize(void)
 {
   unsigned int              chan;
   struct IntUartInfoStruct *info;
   rtems_isr_entry           old_handler;
   rtems_interrupt_level     level;
 
   for ( chan = 0; chan < MAX_UART_INFO; chan++ ) {
     info = &IntUartInfo[chan];
 
     info->ttyp     = NULL;
     info->rx_in    = 0;
     info->rx_out   = 0;
     info->baud     = -1;
     info->databits = -1;
     info->parity   = -1;
     info->stopbits = -1;
     info->hwflow   = -1;
     info->iomode   = TERMIOS_POLLED;
 
     MCF5282_UART_UACR(chan) = 0;
     MCF5282_UART_UIMR(chan) = 0;
     if ( info->iomode != TERMIOS_POLLED ) {
       rtems_interrupt_catch (IntUartInterruptHandler,
                    UART_INTC0_IRQ_VECTOR(chan),
                    &old_handler);
     }
 
     /* set uart default values */
     IntUartSetAttributes(chan, NULL);
 
     /* unmask interrupt */
     rtems_interrupt_disable(level);
     switch(chan) {
       case 0:
         MCF5282_INTC0_ICR13 = MCF5282_INTC_ICR_IL(UART0_IRQ_LEVEL) |
                               MCF5282_INTC_ICR_IP(UART0_IRQ_PRIORITY);
         MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT13 |
                               MCF5282_INTC_IMRL_MASKALL);
         break;
 
     case 1:
       MCF5282_INTC0_ICR14 = MCF5282_INTC_ICR_IL(UART1_IRQ_LEVEL) |
                             MCF5282_INTC_ICR_IP(UART1_IRQ_PRIORITY);
       MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT14 |
                             MCF5282_INTC_IMRL_MASKALL);
     break;
 
     case 2:
       MCF5282_INTC0_ICR15 = MCF5282_INTC_ICR_IL(UART2_IRQ_LEVEL) |
                             MCF5282_INTC_ICR_IP(UART2_IRQ_PRIORITY);
       MCF5282_INTC0_IMRL &= ~(MCF5282_INTC_IMRL_INT15 |
                 MCF5282_INTC_IMRL_MASKALL);
       break;
     }
     rtems_interrupt_enable(level);
 
   } /* of chan loop */
 
 
 } /* IntUartInitialise */
 
 
 /*
  * Function : IntUartInterruptWrite
  *
  * Description : This writes a single character to the appropriate uart
  * channel. This is either called during an interrupt or in the user's task
  * to initiate a transmit sequence. Calling this routine enables Tx
  * interrupts.
  */
 static ssize_t IntUartInterruptWrite(
   int         minor,
   const char *buf,
   size_t      len
 )
 {
   if (len > 0) {
     /* write out character */
     MCF5282_UART_UTB(minor) = *buf;
 
     /* enable tx interrupt */
     IntUartInfo[minor].uimr |= MCF5282_UART_UIMR_TXRDY;
     MCF5282_UART_UIMR(minor) = IntUartInfo[minor].uimr;
   }
 
   return 0;
 }
 
 /*
  * Function : IntUartInterruptOpen
  *
  * Description : This enables interrupts when the tty is opened.
  */
 static int IntUartInterruptOpen(
   int   major,
   int   minor,
   void *arg
 )
 {
   struct IntUartInfoStruct   *info = &IntUartInfo[minor];
 
   /* enable the uart */
   MCF5282_UART_UCR(minor) = (MCF5282_UART_UCR_TX_ENABLED |
                              MCF5282_UART_UCR_RX_ENABLED);
 
   /* check to see if interrupts need to be enabled */
   if ( info->iomode != TERMIOS_POLLED ) {
     /* enable rx interrupts */
     info->uimr |= MCF5282_UART_UIMR_FFULL;
     MCF5282_UART_UIMR(minor) = info->uimr;
   }
 
   /* check to see if doing hardware flow control */
   if ( info->hwflow ) {
     /* assert the RTS line */
     MCF5282_UART_UOP1(minor) = 1;
   }
 
   return 0;
 }
 
 /*
  * Function : IntUartInterruptClose
  *
  * Description : This disables interrupts when the tty is closed.
  */
 static int IntUartInterruptClose(
   int   major,
   int   minor,
   void *arg
 )
 {
   struct IntUartInfoStruct   *info = &IntUartInfo[minor];
 
   /* disable the interrupts and the uart */
   MCF5282_UART_UIMR(minor) = 0;
   MCF5282_UART_UCR(minor) =
     (MCF5282_UART_UCR_TX_DISABLED | MCF5282_UART_UCR_RX_DISABLED);
 
   /* reset values */
   info->ttyp     = NULL;
   info->uimr       = 0;
   info->rx_in    = 0;
   info->rx_out   = 0;
 
   return 0;
 }
 
 /*
  * Function : IntUartTaskRead
  *
  * Description : This reads all available characters from the internal uart
  * and places them into the termios buffer.  The rx interrupts will be
  * re-enabled after all data has been read.
  */
 static int IntUartTaskRead(int minor)
 {
   char                        buffer[RX_BUFFER_SIZE];
   int                         count;
   int                         rx_in;
   int                         index = 0;
   struct IntUartInfoStruct   *info  = &IntUartInfo[minor];
 
   /* determine number of values to copy out */
   rx_in = info->rx_in;
   if ( info->rx_out <= rx_in ) {
     count = rx_in - info->rx_out;
   } else {
     count = (RX_BUFFER_SIZE - info->rx_out) + rx_in;
   }
 
   /* copy data into local buffer from rx buffer */
   while ( ( index < count ) && ( index < RX_BUFFER_SIZE ) ) {
     /* copy data byte */
     buffer[index] = info->rx_buffer[info->rx_out];
     index++;
 
     /* increment rx buffer values */
     info->rx_out++;
     if ( info->rx_out >= RX_BUFFER_SIZE ) {
       info->rx_out = 0;
     }
   }
 
   /* check to see if buffer is not empty */
   if ( count > 0 ) {
     /* set characters into termios buffer  */
     rtems_termios_enqueue_raw_characters(info->ttyp, buffer, count);
   }
 
   return EOF;
 }
 
 
 
 /*
  * Function : IntUartPollRead
  *
  * Description : This reads a character from the internal uart. It returns
  * to the caller without blocking if not character is waiting.
  */
 static int IntUartPollRead(int minor)
 {
   if ( (MCF5282_UART_USR(minor) & MCF5282_UART_USR_RXRDY) == 0 )
     return-1;
 
   return MCF5282_UART_URB(minor);
 }
 
 
 /*
  * Function : IntUartPollWrite
  *
  * Description : This writes out each character in the buffer to the
  * appropriate internal uart channel waiting till each one is sucessfully
  * transmitted.
  */
 static ssize_t IntUartPollWrite(
   int         minor,
   const char *buf,
   size_t      len
 )
 {
   size_t retval = len;
   /* loop over buffer */
 
   while ( len-- ) {
     /* block until we can transmit */
     while ( (MCF5282_UART_USR(minor) & MCF5282_UART_USR_TXRDY) == 0 )
       continue;
     /* transmit data byte */
     MCF5282_UART_UTB(minor) = *buf++;
   }
   return retval;
 }
 
 /*
  * Function : console_initialize
  *
  * Description : This initialises termios, both sets of uart hardware before
  * registering /dev/tty devices for each channel and the system /dev/console.
  */
 rtems_device_driver console_initialize(
   rtems_device_major_number  major,
   rtems_device_minor_number  minor,
   void                      *arg
 )
 {
   rtems_status_code status;
 
   /* Set up TERMIOS */
   rtems_termios_initialize ();
 
   /* set io modes for the different channels and initialize device */
   IntUartInfo[minor].iomode = TERMIOS_IRQ_DRIVEN;
   IntUartInitialize();
 
   /* Register the console port */
   status = rtems_io_register_name ("/dev/console", major, CONSOLE_PORT);
   if ( status != RTEMS_SUCCESSFUL ) {
     rtems_fatal_error_occurred (status);
   }
 
   /* Register the other port */
   if ( CONSOLE_PORT != 0 ) {
     status = rtems_io_register_name ("/dev/tty00", major, 0);
     if ( status != RTEMS_SUCCESSFUL ) {
       rtems_fatal_error_occurred (status);
     }
   }
   if ( CONSOLE_PORT != 1 ) {
     status = rtems_io_register_name ("/dev/tty01", major, 1);
     if ( status != RTEMS_SUCCESSFUL ) {
       rtems_fatal_error_occurred (status);
     }
   }
 
   return RTEMS_SUCCESSFUL;
 }
 
 /*
  * Function : console_open
  *
  * Description : This actually opens the device depending on the minor
  * number set during initialisation. The device specific access routines are
  * passed to termios when the devices is opened depending on whether it is
  * polled or not.
  */
 rtems_device_driver console_open(
   rtems_device_major_number major,
   rtems_device_minor_number minor,
   void  * arg
 )
 {
   rtems_status_code               status = RTEMS_INVALID_NUMBER;
   rtems_libio_open_close_args_t  *args   = (rtems_libio_open_close_args_t *)arg;
   struct IntUartInfoStruct       *info;
 
   static const rtems_termios_callbacks IntUartPollCallbacks = {
     NULL,                 /* firstOpen */
     NULL,                 /* lastClose */
     IntUartPollRead,      /* pollRead */
     IntUartPollWrite,     /* write */
     IntUartSetAttributes, /* setAttributes */
     NULL,                 /* stopRemoteTx */
     NULL,                 /* startRemoteTx */
     TERMIOS_POLLED        /* mode */
   };
   static const rtems_termios_callbacks IntUartIntrCallbacks = {
     IntUartInterruptOpen,  /* firstOpen */
     IntUartInterruptClose, /* lastClose */
     NULL,                  /* pollRead */
     IntUartInterruptWrite, /* write */
     IntUartSetAttributes,  /* setAttributes */
     NULL,                  /* stopRemoteTx */
     NULL,                  /* startRemoteTx */
     TERMIOS_IRQ_DRIVEN     /* mode */
   };
 
   static const rtems_termios_callbacks IntUartTaskCallbacks = {
     IntUartInterruptOpen,  /* firstOpen */
     IntUartInterruptClose, /* lastClose */
     IntUartTaskRead,       /* pollRead */
     IntUartInterruptWrite, /* write */
     IntUartSetAttributes,  /* setAttributes */
     NULL,                  /* stopRemoteTx */
     NULL,                  /* startRemoteTx */
     TERMIOS_TASK_DRIVEN    /* mode */
   };
 
   /* open the port depending on the minor device number */
   if ( ( minor >= 0 ) && ( minor < MAX_UART_INFO ) ) {
     info = &IntUartInfo[minor];
     switch ( info->iomode ) {
       case TERMIOS_POLLED:
         status = rtems_termios_open(major, minor, arg, &IntUartPollCallbacks);
         break;
       case TERMIOS_IRQ_DRIVEN:
         status = rtems_termios_open(major, minor, arg, &IntUartIntrCallbacks);
         info->ttyp = args->iop->data1;
         break;
       case TERMIOS_TASK_DRIVEN:
         status = rtems_termios_open(major, minor, arg, &IntUartTaskCallbacks);
         info->ttyp = args->iop->data1;
         break;
     }
   }
 
   return status;
 }
 
 /*
  * Function : console_close
  *
  * Description : This closes the device via termios
  */
 rtems_device_driver console_close(
   rtems_device_major_number major,
   rtems_device_minor_number minor,
   void   * arg
 )
 {
   return rtems_termios_close(arg);
 }
 
 /*
  * Function : console_read
  *
  * Description : Read from the device via termios
  */
 rtems_device_driver console_read(
   rtems_device_major_number  major,
   rtems_device_minor_number  minor,
   void                      *arg
 )
 {
   return rtems_termios_read(arg);
 }
 
 /*
  * Function : console_write
  *
  * Description : Write to the device via termios
  */
 rtems_device_driver console_write(
   rtems_device_major_number  major,
   rtems_device_minor_number  minor,
   void                      *arg
 )
 {
   return rtems_termios_write(arg);
 }
 
 /*
  * Function : console_ioctl
  *
  * Description : Pass the IOCtl call to termios
  */
 rtems_device_driver console_control(
   rtems_device_major_number  major,
   rtems_device_minor_number  minor,
   void                      *arg
 )
 {
   return rtems_termios_ioctl(arg);
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team