WebSVN - shark - Rev 105 - /shark/trunk/drivers/oldchar/scom.c

/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Paolo Gai <pj@gandalf.sssup.it>
* Massimiliano Giorgi <massy@gandalf.sssup.it>
* Luca Abeni <luca@gandalf.sssup.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/

/**
------------
CVS : $Id: scom.c,v 1.1 2003-03-24 10:54:17 pj Exp $

File: $File$
Revision: $Revision: 1.1 $
Last update: $Date: 2003-03-24 10:54:17 $
------------

Author: Massimiliano Giorgi

Author: Gerardo Lamastra
Date: 9/5/96

File: SCOM.C
Revision: 1.0g

**/

/*
* Copyright (C) 2000 Paolo Gai
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/

/* Serial communication device */
/* This implementation is capable of handling 4 distinct COM ports */
/* The COM port settings are the standard PC settings: */
/* PORT ADDRESS IRQ */
/* 1 0x3F8 4 */
/* 2 0x2F8 3 */
/* 3 0x3E8 4 */
/* 4 0x2E8 2 */

/* By Massy
* I have modified the fast handler routines to support serial
* mouse better (see below)
*/

//#include <string.h>
//#include <stdlib.h>
//#include <cons.h>

#include <kernel/kern.h>
//#include "exc.h"

#include <modules/sem.h>
#include <drivers/scom.h>

/* #define __DEBUG_SERIAL__ */
/* #define __STUB__ */

/* Base address for each standard COM link */
static unsigned com_base[] = {0x03F8,0x02F8,0x03E8,0x02E8};
/* Irq linked to each serial channel */
static unsigned com_irq[] = {COM1_IRQ,COM2_IRQ,COM3_IRQ,COM4_IRQ};
/* COM port which shares interrupt with indexed one */
/* I assume standard AT assignement where each irq line can */
/* hold up to 2 different COM port */
static const int com_share[] = {COM3,COM4,COM1,COM2};

/* Used for decoding the IIR status */
const int IIRbits[] = {MS_CHANGED,TX_EMPTY,RX_FULL,LS_CHANGED};

/* The descriptor of a serial link */
/* Each array entry is associated to a COM port */
/* The control field is used to specify which kind of interrupts */
/* are going to be served; the status field tracks if the entry */
/* is curretly used & if the shared fast handler is linked */
/* The semaphores are opened if you use an asyncronous server */
/* with the link */

struct COM_LINK com_link[COM_LINKS];

/* Register level access functions */

unsigned com_read(unsigned port,unsigned reg)
{
unsigned b;
if (port > 3 || reg > 7) return(0);
b = ll_in(com_base[port]+reg);
return(b);
}

void com_write(unsigned port,unsigned reg,unsigned value)
{
if (port > 3 || reg > 7) return;
ll_out(com_base[port]+reg,value);
}

/* Polled send/receive */

void com_send(unsigned port,BYTE b)
{
while ((com_read(port,LSR) & 32) == 0);
com_write(port,THR,b);
}

unsigned com_receive(unsigned port)
{
while ((com_read(port,LSR) & 1) == 0);
return(com_read(port,RBR));
}

/* Fast routines for cascaded irq */

/* By massy */
/* com_fast must be called if there isn't a server
* and an interrupt is detected (so sermouse.c module can
* activate mouse task only if a packet not a byte is received).
*/
static void dummy(int x) {}
void (*com_fast)(int)=dummy;

#ifdef __DEBUG_SERIAL__
int fast_times1 = 0,fast_times3 = 0;
#endif

static void com_1_3_fast(int n)
{
unsigned iir1,iir3;
iir1 = DECODE(com_read(COM1,IIR));
iir3 = DECODE(com_read(COM3,IIR));
if ((iir1 & com_link[COM1].control)) {
#ifdef __DEBUG_SERIAL__
fast_times1++;
#endif
com_write(COM1,IER,0);
com_link[COM1].request = iir1;
if (com_link[COM1].server==NIL)
com_fast(COM1);
else
task_activate(com_link[COM1].server);
}
else if ((iir3 & com_link[COM3].control)) {
#ifdef __DEBUG_SERIAL__
fast_times3++;
#endif
com_write(COM3,IER,0);
com_link[COM3].request = iir3;
if (com_link[COM3].server==NIL)
com_fast(COM3);
else
task_activate(com_link[COM3].server);
}
}

#ifdef __DEBUG_SERIAL__
int fast_times2 = 0,fast_times4 = 0;
#endif

static void com_2_4_fast(int n)
{
unsigned iir2,iir4;
iir2 = DECODE(com_read(COM2,IIR));
iir4 = DECODE(com_read(COM4,IIR));
if ((iir2 & com_link[COM2].control)) {
#ifdef __DEBUG_SERIAL__
fast_times2++;
#endif
com_write(COM2,IER,0);
com_link[COM2].request = iir2;
if (com_link[COM2].server==NIL)
com_fast(COM2);
else
task_activate(com_link[COM2].server);
}
else if ((iir4 & com_link[COM4].control)) {
#ifdef __DEBUG_SERIAL__
fast_times4++;
#endif
com_write(COM4,IER,0);
com_link[COM4].request = iir4;
if (com_link[COM4].server==NIL)
com_fast(COM4);
else
task_activate(com_link[COM4].server);
}
}

/* Initialize a serial channel */

int com_open(unsigned port,DWORD speed,BYTE parity,BYTE len,BYTE stop)
{
unsigned long div,b_mask;

/* Check if link is already open */
cli();
if (com_link[port].status & LINK_BUSY) {
sti();
return(-1);
} else com_link[port].status |= LINK_BUSY;
sti();

/* Now set up the serial link */
b_mask = (parity & 3) * 8 + (stop & 1) * 4 + ((len - 5) & 3);
div = 115200L / speed;
/* Clear serial interrupt enable register */
com_write(port,IER,0);
/* Empty input buffer */
com_read(port,RBR);
/* Activate DLAB bit for speed setting */
com_write(port,LCR,0x80);
/* Load baud divisor */
com_write(port,0,div & 0x00FF);
div >>= 8;
com_write(port,1,div & 0x00FF);
/* Load control word (parity,stop bit,bit len) */
com_write(port,LCR,b_mask);
/* Attiva OUT1 & OUT2 */
com_write(port,MCR,0x0C);
return(1);
}

/* Link a particular server to a serial channel */
/* The semaphores are opened to syncronize the server and the */
/* application task which use serial communication */

int com_server(unsigned port,unsigned control,PID server)
{
unsigned hndl = com_irq[port];
unsigned shared = com_share[port];
void (*com_fast)(int n);
/* Select appropriate fast routine */
if (port == COM1 || port == COM3) com_fast = com_1_3_fast;
else if (port == COM2 || port == COM4) com_fast = com_2_4_fast;
else return(-1);
if ((control & (RX_FULL|TX_EMPTY)) == 0) return(-1);
/* If the fast routine is not already installed, install it! */
cli();
if (!(com_link[port].status & FAST_INSTALLED)) {
bit_on(com_link[port].status,FAST_INSTALLED);
bit_on(com_link[shared].status,FAST_INSTALLED);
handler_set(hndl,com_fast,NIL);
#ifdef __DEBUG_SERIAL__
cputs("Handler OK\n");
#endif
}
sti();
/* Set com link tasks & flags */
com_link[port].control = control;
com_link[port].server = server;
com_link[port].msk = 0;
if (control & RX_FULL) sem_init(&com_link[port].rx_sem,0,0);
if (control & TX_EMPTY) sem_init(&com_link[port].tx_sem,0,0);
sem_init(&com_link[port].mutex,0,1);
return(1);
}

/* Close port channel & release the server */

int com_close(unsigned port)
{
unsigned hndl = com_irq[port];
unsigned shared = com_share[port];

/* Check if fast is already installed */
cli();
if (!(com_link[port].status & LINK_BUSY)) {
sti();
return(-1);
} else {
if (com_link[port].control & RX_FULL) sem_destroy(&com_link[port].rx_sem);
if (com_link[port].control & TX_EMPTY) sem_destroy(&com_link[port].tx_sem);
com_write(port,IER,0);
com_read(port,IIR);
com_read(port,RBR);
com_link[port].status = 0;
com_link[port].control = 0;
com_link[port].msk = 0;
sti();
sem_destroy(&com_link[port].mutex);
if (com_link[port].server != NIL) {
task_kill(com_link[port].server);
com_link[port].server = NIL;
}
}
/* If the fast routine is no more necessary, remove it */
if (!(com_link[shared].status & FAST_INSTALLED))
handler_remove(hndl);
/* If the other link still uses it, we must remember this */
else com_link[port].status = FAST_INSTALLED;
return(1);
}

#ifdef __DEBUG_SERIAL__
int rx_time = 0;
int tx_time = 0;
#endif

/* This is the full duplex server; used for bidirectional data */
/* transmission. */
/* As intr is masked, the server can only be activated once */
/* and operates in mutex with the fast handler */
/* This server operates in conjunction with the com_Async... */
/* procedures! */

TASK duplexServer(int port)
{
char data;
for(;;) {
if (com_link[port].request & RX_FULL) {
#ifdef __DEBUG_SERIAL__
putc_xy(78,0,RED,'R');
rx_time++;
#endif
data = com_read(port,RBR);
*(com_link[port].rx_buf + com_link[port].rx_cnt) = data;
com_link[port].rx_cnt++;
if (com_link[port].rx_cnt == com_link[port].rx_len) {
bit_off(com_link[port].msk,RX_FULL);
sem_post(&com_link[port].rx_sem);
}
}
if (com_link[port].request & TX_EMPTY) {
#ifdef __DEBUG_SERIAL__
putc_xy(79,0,GREEN,'T');
tx_time++;
#endif
data = *(com_link[port].tx_buf + com_link[port].tx_cnt);
com_link[port].tx_cnt++;
com_write(port,THR,data);
if (com_link[port].tx_cnt == com_link[port].tx_len) {
bit_off(com_link[port].msk,TX_EMPTY);
sem_post(&com_link[port].tx_sem);
}
}
cli();
com_write(port,IER,com_link[port].msk);
task_endcycle();
sti();
}
}

/* This routines provides asyncronous decoupling between the server */
/* and the tasks which produce/consume serial data */

void com_AsyncSend(int port,void *buf,unsigned len)
{
sem_wait(&com_link[port].mutex);
com_link[port].tx_buf = buf;
com_link[port].tx_cnt = 0;
com_link[port].tx_len = len;
bit_on(com_link[port].msk,TX_EMPTY);
sem_post(&com_link[port].mutex);
com_write(port,IER,com_link[port].msk);
sem_wait(&com_link[port].tx_sem);
}

void com_AsyncReceive(int port,void *buf,unsigned len)
{
sem_wait(&com_link[port].mutex);
com_link[port].rx_buf = buf;
com_link[port].rx_cnt = 0;
com_link[port].rx_len = len;
bit_on(com_link[port].msk,RX_FULL);
sem_post(&com_link[port].mutex);
com_write(port,IER,com_link[port].msk);
sem_wait(&com_link[port].rx_sem);
}

/* Receive Only Server */
/* This server is used for passive devices which cannot receive */
/* data, but only transmit. I assume that only one byte is pro- */
/* cessed each time and the byte is got to the control process */

TASK rxServer(int port)
{
static char data;
com_link[port].rx_buf = &data;
for(;;) {
#ifdef __DEBUG_SERIAL__
putc_xy(76,0,YELLOW,'R');
#endif
data = com_read(port,RBR);
sem_post(&com_link[port].rx_sem);
cli();
com_write(port,IER,com_link[port].msk);
task_endcycle();
sti();
}
}

/* Debug Stub */

#ifdef __STUB__

#include "keyb.h"

TASK Visualize(void)
{
char str[40];
char buf[80];
unsigned long times = 0;

for (;;) {
com_AsyncReceive(COM2,str,10);
sprintf(buf,"Str : %s (Times : %lu)",str,times++);
puts_xy(0,1,WHITE,buf);
}
}

TASK Sender(void)
{
char buf[80];
unsigned long times = 0;
cputs("Sender has started...\n");
for (;;) {
buf[0] = keyb_getchar();
if (buf[0] == 'x') task_activate(MAIN_INDEX);
if ((times % 10) == 9) buf[0] = 0;
com_AsyncSend(COM2,buf,1);
sprintf(buf,"Sender (Times : %lu)",times++);
puts_xy(0,3,WHITE,buf);
}
} 0

void main()
{
PID p1,p2,p3;
BYTE m1 = TX_EMPTY|RX_FULL;
BYTE m2 = RX_FULL;
BYTE m3 = TX_EMPTY;
MODEL m = BASE_MODEL;
MODEL mm = BASE_MODEL;

sys_init(1000,uSec,0);
keyb_init(HARD,50);
clear();
/* This is the sequence of operations needed to setup */
/* a serial asyncronous bidirectional link */
task_def_arg(m,COM2);
task_def_wcet(m,500);
p1 = task_create("ComDuplex",duplexServer,HARD,APERIODIC,100,&m);
if (p1 == -1) {
ll_printf("Error creating comduplex task\n");
sys_end();
exit(-1);
}
com_open(COM2,9600,NONE,8,1);
com_server(COM2,m1,p1);

/* Well, that is some other stuff ... */
task_def_wcet(mm,500);
p2 = task_create("Visor",Visualize,NRT,APERIODIC,11,&mm);
p3 = task_create("Sender",Sender,NRT,APERIODIC,11,&mm);
task_activate(p2);
task_activate(p3);
task_endcycle();
sys_end();
#ifdef __DEBUG_SERIAL__
cprintf("RxServer was activated %d times\n",rx_time);
cprintf("TxServer was activated %d times\n",tx_time);
cprintf("Fast : %d\n",fast_times1);
#endif
}

#endif

Subversion Repositories shark

(root)/shark/trunk/drivers/oldchar/scom.c @ 120 - Rev 105