OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/rtos/rtems/c/src/lib/libbsp/i960/rxgen960/console
    from Rev 30 to Rev 173
    ↔ Reverse comparison
  •

Rev 30 → Rev 173

/serial.c
0,0 → 1,363
/*
* $Id: serial.c,v 1.2 2001-09-27 11:59:58 chris Exp $
*/
 
#include "serial.h"
#include "rtems.h"
 
 
typedef unsigned char uchar ; /* Abbreviations */
typedef unsigned short ushort ;
typedef unsigned long ulong ;
int DBGConsole_make_sync = 0;
#define CONSOLE_CHANNELS 1
 
#define MAX_CONSOLE 4
static int consoles[MAX_CONSOLE];
static int active_consoles = 0;
static struct{
rtems_id sem;
int rx;
int cnt;
char in_line[128];
}cons_input[MAX_CONSOLE];
 
 
 
/* This uses the message out and in buffers as serial emulator.
Pretty stupid eh?
*/
 
#define uart1 ((volatile unsigned char *)0x1318)
#define uart1_rx ((volatile unsigned int *)0x1310)
 
#define NUM_UARTS 1
static volatile unsigned int * uart = { uart1 };
static volatile unsigned int * uart_rx = { uart1_rx };
 
 
extern void display_msg(void);
/*extern int sprintf();*/
 
 
 
int
console_uartinit(unsigned int BAUDRate)
{
#ifdef CONSOLE_CHANNELS
void cons_isr();
rpmu_attach_inmsg0(cons_isr);
#endif
return(0);
}
 
/* Introduce a new console channel */
console_new(char * name)
{
#ifdef CONSOLE_CHANNELS
unsigned int x, stat;
x = 0xfe000000 | (name[0] << 16) | (name[1] << 8) | name[2];
do {
stat = *uart;
} while (DBGConsole_make_sync && (stat != 0));
*uart = x;
x = ( name[3] << 24) | ( name[4] << 16) | ( name[5] << 8) | name[6] ;
do {
stat = *uart;
} while (DBGConsole_make_sync && (stat != 0));
*uart = x;
active_consoles += 1;
rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &consoles[active_consoles] );
#endif
}
 
 
/***********************************************************************
*** Transmit character to host.
*** put the console ID in upper byte
***
***********************************************************************/
 
int console_sps_putc(int cc)
{
register unsigned char stat;
int rtid, i;
unsigned int ch;
unsigned int level;
#ifdef CONSOLE_CHANNELS
rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &rtid );
ch = cc & 0xff;
for(i=1; i <= active_consoles; i++){
if( rtid == consoles[i]){
ch |= (i ) << 24 ;
break;
}
}
#else
ch = cc;
#endif
 
/*
* Pause until there is room in the UART transmit
* buffer.
*/
 
if (ch == -1)
return ch;
 
wait:
do {
stat = *uart;
} while (DBGConsole_make_sync && (stat != 0));
rtems_interrupt_disable(level);
if( (*uart != 0) && DBGConsole_make_sync){
rtems_interrupt_enable(level);
goto wait;
}
 
/*
* Transmit data. (Junk)
*/
 
*uart = ch;
rtems_interrupt_enable(level);
return cc;
 
}
 
 
/*
* putnum -- print a 32 bit number in hex
*/
int
putnum (num)
unsigned int num;
{
char buffer[9];
int count;
int digit;
for (count = 7 ; count >= 0 ; count--) {
digit = (num >> (count * 4)) & 0xf;
if (digit <= 9)
console_sps_putc( (char) ('0' + digit));
else
console_sps_putc( (char) ('A' - 10 + digit));
}
}
 
/*
* putmem -- print the specified memory block
*/
void
putmem (addr, num)
char *addr;
unsigned int num;
{
int i = 0;
int j = 0;
int val = 0;
int digit = 0;
console_sps_putc(13);
console_sps_putc(10);
putnum((unsigned int) addr);
console_sps_putc(':');
console_sps_putc(' ');
while(num)
{
val = *addr;
 
for (j = 0; j < 2; j++)
{
digit = (val & 0xf0) >> 4;
val <<= 4;
 
if (digit < 10)
{
console_sps_putc(digit + '0');
}
else
{
console_sps_putc(digit - 10 + 'A');
}
}
console_sps_putc(' ');
 
num--;
addr++;
if (++i == 16)
{
console_sps_putc(13);
console_sps_putc(10);
putnum((unsigned int) addr);
console_sps_putc(':');
console_sps_putc(' ');
i = 0;
}
}
console_sps_putc(13);
console_sps_putc(10);
}
 
/*
* putcmem -- print the specified pci config memory block
*/
void
putcmem (addr, num)
unsigned char *addr;
unsigned int num;
{
int i = 0;
int j = 0;
unsigned short val = 0;
int digit = 0;
unsigned int *satucmd = (unsigned int *) 0x1298;
unsigned int *soccar = (unsigned int *) 0x12a8;
unsigned int *soccdp = (unsigned int *) 0x12b0;
*satucmd = 4;
 
console_sps_putc(13);
console_sps_putc(10);
putnum((unsigned int) addr);
console_sps_putc(':');
console_sps_putc(' ');
while(num)
{
*soccar = (unsigned int) addr;
val = *soccdp;
 
for (j = 0; j < 4; j++)
{
digit = (val & 0xf000) >> 12;
val <<= 4;
 
if (digit < 10)
{
console_sps_putc(digit + '0');
}
else
{
console_sps_putc(digit - 10 + 'A');
}
}
console_sps_putc(' ');
 
num -= 2;
addr += 2;
if (++i == 8)
{
console_sps_putc(13);
console_sps_putc(10);
putnum((unsigned int) addr);
console_sps_putc(':');
console_sps_putc(' ');
i = 0;
}
}
console_sps_putc(13);
console_sps_putc(10);
}
 
/***********************************************************************
*** Read character from host.
***********************************************************************/
#ifdef CONSOLE_CHANNELS
int console_sps_getc()
{
int consinx;
int rtid, i;
unsigned int level, level2;
char ch;
consinx = 0;
rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &rtid );
for(i=1; i <= active_consoles; i++){
if( rtid == consoles[i]){
consinx = i ;
break;
}
}
if( i > active_consoles)
consinx = 0;
if( cons_input[consinx].sem == 0){
rtems_name sname;
sname = rtems_build_name('S','U','X',(char)(consinx + '0'));
rtems_semaphore_create(sname, 0, RTEMS_DEFAULT_ATTRIBUTES, 0, &cons_input[consinx].sem);
cons_input[consinx].rx = 0;
}
while( cons_input[consinx].cnt == cons_input[consinx].rx){
rtems_semaphore_obtain(cons_input[consinx].sem, RTEMS_WAIT, 0);
/* rtems_task_wake_after( RTEMS_YIELD_PROCESSOR);*/
}
rtems_interrupt_disable(level);
i = cons_input[consinx].rx;
ch = cons_input[consinx].in_line[i];
i++;
if( i >= sizeof( cons_input[consinx].in_line))
i = 0;
cons_input[consinx].rx = i;
rtems_interrupt_enable(level);
return ch;
}
 
void cons_isr()
{
unsigned int i, chin, consinx, st;
chin = *uart_rx;
consinx = chin >> 24;
if( consinx > active_consoles)
goto release;
i = cons_input[consinx].cnt;
cons_input[consinx].in_line[i] = chin & 0xff;
i++;
if( i >= sizeof( cons_input[consinx].in_line))
i = 0;
cons_input[consinx].cnt = i;
st = rtems_semaphore_release( cons_input[consinx].sem);
release:
*uart_rx = 0;
}
#else
volatile int console_foo = 0;
int console_sps_getc()
{
volatile unsigned int stat;
register int ch;
 
stat = *uart_rx;
while (stat == 0)
{
rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );
stat = *uart_rx;
console_foo++;
}
*uart_rx = 0;
 
ch = stat;
 
return ch;
}
#endif
 
/***********************************************************************
*** check character from host.
***********************************************************************/
 
int console_sps_kbhit()
{
register unsigned short stat;
 
stat = *uart;
return ( stat != 0);
}
 
 
 
 
/console.c
0,0 → 1,264
/*
* This file contains the template for a console IO package.
*
* COPYRIGHT (c) 1989-1997.
* On-Line Applications Research Corporation (OAR).
* Copyright assigned to U.S. Government, 1994.
*
* The license and distribution terms for this file may in
* the file LICENSE in this distribution or at
* http://www.OARcorp.com/rtems/license.html.
*
* $Id: console.c,v 1.2 2001-09-27 11:59:58 chris Exp $
*/
 
#define NO_BSP_INIT
 
 
/* only one of the following can be defined */
#define SERIAL_INPUT /* use serial input */
 
#include <bsp.h>
#include <rtems/libio.h>
#include "concntl.h"
/* #include "pcimsgreg.h" XXX JRS */
 
#ifndef lint
static char _sccsid[] = "@(#)console.c 09/12/96 1.13\n";
#endif
 
/* console_initialize
*
* This routine initializes the console IO driver.
*
* Input parameters: NONE
*
* Output parameters: NONE
*
* Return values:
*/
 
rtems_device_driver console_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code status;
if ( console_pmr_init(*(unsigned32*)arg) )
return RTEMS_INVALID_NUMBER;
 
status = rtems_io_register_name(
"/dev/console",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
return RTEMS_SUCCESSFUL;
}
 
 
/* is_character_ready
*
* This routine returns TRUE if a character is available.
*
* Input parameters: NONE
*
* Output parameters: NONE
*
* Return values:
*/
 
rtems_boolean is_character_ready(
char *ch
)
{
*ch = '\0'; /* return NULL for no particular reason */
return(console_pmr_kbhit());
}
 
/* inbyte
*
* This routine reads a character from the SOURCE.
*
* Input parameters: NONE
*
* Output parameters: NONE
*
* Return values:
* character read from SOURCE
*/
 
char inbyte( unsigned int minor )
{
/*
* If polling, wait until a character is available.
*/
return console_pmr_getc();
}
 
/* outbyte
*
* This routine transmits a character out the SOURCE. It may support
* XON/XOFF flow control.
*
* Input parameters:
* ch - character to be transmitted
*
* Output parameters: NONE
*/
 
void outbyte( unsigned int minor,
char ch
)
{
console_pmr_putc( ch );
 
/*
* Carriage Return/New line translation.
*/
 
if ( ch == '\n' )
outbyte( minor, '\r' );
}
 
 
/*
* Open entry point
*/
 
rtems_device_driver console_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg
)
{
return RTEMS_SUCCESSFUL;
}
/*
* Close entry point
*/
 
rtems_device_driver console_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg
)
{
return RTEMS_SUCCESSFUL;
}
 
/*
* read bytes from the serial port. We only have stdin.
*/
 
rtems_device_driver console_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg
)
{
rtems_libio_rw_args_t *rw_args;
unsigned8 *buffer;
unsigned32 maximum;
unsigned32 count = 0;
rw_args = (rtems_libio_rw_args_t *) arg;
 
buffer = rw_args->buffer;
maximum = rw_args->count;
 
for (count = 0; count < maximum; count++) {
buffer[ count ] = inbyte(minor);
if (buffer[ count ] == '\n' || buffer[ count ] == '\r') {
buffer[ count++ ] = '\n';
buffer[ count ] = 0;
outbyte( minor, '\n' ); /* newline */
break;
}
else if (buffer[ count ] == '\b' && count > 0 )
{
outbyte( minor, '\b' ); /* move back one space */
outbyte( minor, ' ' ); /* erase the character */
outbyte( minor, '\b' ); /* move back one space */
count-=2;
}
else
outbyte( minor, buffer[ count ] ); /* echo the character */
}
 
rw_args->bytes_moved = count;
return (count > 0) ? RTEMS_SUCCESSFUL : RTEMS_UNSATISFIED;
}
 
/*
* write bytes to the serial port. Stdout and stderr are the same.
*/
 
rtems_device_driver console_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg
)
{
int count;
int maximum;
rtems_libio_rw_args_t *rw_args;
unsigned8 *buffer;
 
rw_args = (rtems_libio_rw_args_t *) arg;
 
buffer = rw_args->buffer;
maximum = rw_args->count;
 
for (count = 0; count < maximum; count++) {
if ( buffer[ count ] == '\n') {
outbyte(minor,'\r');
}
outbyte( minor,buffer[ count ] );
}
 
rw_args->bytes_moved = maximum;
return 0;
}
 
/*
* IO Control entry point
*/
 
rtems_device_driver console_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void * arg
)
{
if (!arg)
return RTEMS_INVALID_ADDRESS;
 
switch( ((console_ioctl_request_t *)arg)->ioctl_type )
{
case CON_KBHIT:
/* check if keyboard was hit */
((console_ioctl_request_t *)arg)->param = console_pmr_kbhit();
break;
 
case CON_GET_RAW_BYTE:
((console_ioctl_request_t *)arg)->param = inbyte(minor);
break;
 
case CON_SEND_RAW_BYTE:
outbyte(minor, ((console_ioctl_request_t *)arg)->param);
break;
 
default:
break;
}
 
return RTEMS_SUCCESSFUL;
}
/serial.h
0,0 → 1,8
/*
* $Id: serial.h,v 1.2 2001-09-27 11:59:58 chris Exp $
*/
 
int console_uartinit(unsigned int BAUDRate);
int console_sps_putc(int ch);
int console_sps_getc();
int console_sps_kbhit();
/concntl.h
0,0 → 1,16
/*
* $Id: concntl.h,v 1.2 2001-09-27 11:59:58 chris Exp $
*/
 
typedef enum
{
CON_KBHIT,
CON_GET_RAW_BYTE,
CON_SEND_RAW_BYTE
} console_ioctl_t;
 
typedef struct
{
console_ioctl_t ioctl_type;
unsigned32 param;
} console_ioctl_request_t;
/Makefile.am
0,0 → 1,32
##
## $Id: Makefile.am,v 1.2 2001-09-27 11:59:58 chris Exp $
##
 
AUTOMAKE_OPTIONS = foreign 1.4
 
PGM = $(ARCH)/console.rel
 
C_FILES = console.c
C_O_FILES = $(C_FILES:%.c=$(ARCH)/%.o)
 
OBJS = $(C_O_FILES)
 
include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP@.cfg
include $(top_srcdir)/../../../../../../automake/lib.am
 
#
# (OPTIONAL) Add local stuff here using +=
#
 
$(PGM): $(OBJS)
$(make-rel)
 
# the .rel file built here will be put into libbsp.a by ../wrapup/Makefile
 
all-local: $(ARCH) $(OBJS) $(PGM)
 
.PRECIOUS: $(PGM)
 
EXTRA_DIST = concntl.h console.c serial.c serial.h
 
include $(top_srcdir)/../../../../../../automake/local.am

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.