mon_pa.c

moxa多串口卡linux下的驱动源码

/*****************************************************************************/
/* MON_PA.C                                                                  */
/*									     */
/* Copyright (c) Moxa Technologies Inc. 1999. All Rights Reserved.	     */
/*									     */
/* Revision history:							     */
/*	10/95	JOSE							     */
/*     8/5/99   Casper                                                       */
/*****************************************************************************/

#include	<sys/time.h>
//#include        <sys/ioctl.h>
#include        "../mxwinlib/win.h"
#include        "../mxlib/declare.h"
#include	"mon.h"
#include        "../global.h"

#define MOXA_GET_IOQUEUE	(MOXA + 27)
#define MOXA_GETMSTATUS         (MOXA + 65)

/*****************************************************************************/
/* GLOBAL FUNCTIONS							     */
/*****************************************************************************/
int	mon_pa_setup(char *devname, int interval,
                          int flag, int board, int box, int port);

/*****************************************************************************/
/* GLOBAL VARIABLES							     */
/*****************************************************************************/

/*****************************************************************************/
/* STATIC FUNCTIONS							     */
/*****************************************************************************/
static	int	init_menu();
static	int	prepare_menu(char *devname, int board, int box, int port);

/*****************************************************************************/
/* STATIC VARIABLES							     */
/*****************************************************************************/
#define Total_Item	10
#define Max_Col 	1
#define Col_Space	14
static	int		itemflag[Total_Item] = {
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly
};
static	char		*itemdes[Total_Item] = {
	" Device Name  ",
	" Baud Rate    ",
	" Parity       ",
	" Data Bits    ",
	" Stop Bits    ",
	" CTS          ",
	" DSR          ",
	" DCD          ",
	" Input Queue  ",
	" Output Queue "
};
static	struct	GEdit2	menu2 = {
	Edit2Type0, -1, 6, Total_Item,
	"Port Status", 0, 0, 
	{ "PgDn:Next  PgUp:Prev ",
	  " Esc:Exit "},
	0
};


struct WItem	BaudRateMenuItem[] = {
	{F_Active, "50"},
	{F_Active, "75"},
	{F_Active, "110"},
	{F_Active, "134"},
	{F_Active, "150"},
	{F_Active, "200"},
	{F_Active, "300"},
	{F_Active, "600"},
	{F_Active, "1200"},
	{F_Active, "1800"},
	{F_Active, "2400"},
	{F_Active, "4800"},
	{F_Active, "9600"},
	{F_Active, "19200"},
	{F_Active, "38400"},
	{F_Active, "57600"},
	{F_Active, "115200"},
	{F_Active, "230400"},
	{F_Active, "460800"},
	{F_Active, "921600"}
};
struct WItem	ParityMenuItem[] = {
	{F_Active, " None "},
	{F_Active, "  Odd "},
	{F_Active, " Even "},
	{F_Active, " Mark "},
	{F_Active, " Space"}
};
struct WItem	DataBitMenuItem[] = {
	{F_Active, " 5 "},
	{F_Active, " 6 "},
	{F_Active, " 7 "},
	{F_Active, " 8 "}
};
struct WItem	StopBitMenuItem[] = {
	{F_Active, " 1 "},
	{F_Active, " 2 "}
};
struct WItem	YesNoMenuItem[] = {
	{F_Active, "No "},
	{F_Active, "Yes"}
};
struct WItem	EnterMenuItem[] = {
	{F_Active, "CR-LF"},
	{F_Active, " CR  "},
	{F_Active, " LF  "},
	{F_Active, "LF-CR"}
};
struct WItem	OnOffMenuItem[] = {
	{F_Active, "OFF", ' '},
	{F_Active, "ON ", ' '}
};
long BaudMapTab[] = {
     B50, B75, B110, B134, B150, B200, B300, B600, B1200,
     B1800,B2400,B4800,B9600,B19200,B38400,B57600,B115200,
     B230400,B460800,B921600
};

static	int	old_space_ndx;

struct	pstat_info_str {
	uchar	baud;
	uchar	parity;
	uchar	databit;
	uchar	stopbit;
	uchar	CTS;
	uchar	DSR;
	uchar	DCD;
	int	iqueue;
	int	oqueue;
};
static	struct	pstat_info_str	pinfo;
#define	CTS_SIG	0x01
#define DSR_SIG	0x02
#define	DCD_SIG	0x04
static	time_t	t1, t3;
/*****************************************************************************/
/*	FUNCTIONS							     */
/*****************************************************************************/
int	mon_pa_setup(char *devname, int interval, int flag,
                          int board, int box, int port)
{
	int	exit_flag=0, err_flag=0, ret=0, old_space_ndx;
	fd_set	rfdset;
	struct	timeval tm;

	old_space_ndx = init_menu();
	mw_edit2init(&menu2);
	t1 = time(&t3);
	if ( prepare_menu(devname, board, box, port) < 0 )
		err_flag = 1;
	else
		edit2_flush_data(&menu2);
	tm.tv_sec = 1;
	tm.tv_usec = 0;
	FD_ZERO(&rfdset);
	while (exit_flag == 0 && err_flag == 0) {
		FD_SET(tty_fd, &rfdset);
		select(tty_fd+1, &rfdset, NULL, NULL, &tm);
		switch (mw_getkey_nb()) {
		case K_ESC:
		case K_ESC_A:
			exit_flag = 1;
			break;
		case K_PGDOWN:
			if ( flag == MON_BOTTOM )
				break;
			ret = 1;
			exit_flag = 1;
			break;
		case K_PGUP:
			if ( flag == MON_TOP )
				break;
			ret = -1;
			exit_flag = 1;
			break;
		default:
			if (time(&t3) - t1 < interval)
				break;
			t1 = time(&t3);
			if (prepare_menu(devname, board, box, port) < 0)
				err_flag = 1;;
			edit2_flush_data(&menu2);
			break;
		}
	}
	release_space(old_space_ndx);
	mw_edit2end();
	return (ret);
}

static	int	init_menu()
{
	int	i, j, k, old_space_ndx;

	old_space_ndx = get_space_ndx();
	j = sizeof(struct GItem2) * Total_Item;
	menu2.item = (struct GItem2 *)get_space(j);
	for (i = 0; i < Total_Item; i++) {
		menu2.item[i].flag = itemflag[i];
		menu2.item[i].des = itemdes[i];
		menu2.item[i].act_item = 0;
		menu2.item[i].total = Max_Col;
		/* jose: to fit for each column space */
		for (j = 0; j < Max_Col; j++) {
			menu2.item[i].len[j] = Col_Space;
			menu2.item[i].str[j] = get_space(Col_Space + 1);
			for (k = 0; k < Col_Space; k++)
				menu2.item[i].str[j][k] = ' ';
			menu2.item[i].str[j][k] = 0;
		}
	}
	menu2.act_item = 1;
	return(old_space_ndx);
}

static	int	prepare_menu(char *devname, int board, int box, int port)
{
	int			j;

	for (j = 0; j < Max_Col; j++) {
		if (getstatus(devname, board, box, port) < 0){
			return (-1);
                }
		sprintf(menu2.item[0].str[j], "  %10s  ", devname);
		sprintf(menu2.item[1].str[j], "  %9s   ", 
			BaudRateMenuItem[pinfo.baud].str);
		sprintf(menu2.item[2].str[j], "  %9s   ", 
			ParityMenuItem[pinfo.parity].str);
		sprintf(menu2.item[3].str[j], "  %9s   ", 
			DataBitMenuItem[pinfo.databit].str);
		sprintf(menu2.item[4].str[j], "  %9s   ", 
			StopBitMenuItem[pinfo.stopbit].str);
		sprintf(menu2.item[5].str[j], "  %9s   ", 
			OnOffMenuItem[pinfo.CTS].str);
		sprintf(menu2.item[6].str[j], "  %9s   ", 
			OnOffMenuItem[pinfo.DSR].str);
		sprintf(menu2.item[7].str[j], "  %9s   ", 
			OnOffMenuItem[pinfo.DCD].str);
		sprintf(menu2.item[8].str[j], "  %9d   ", pinfo.iqueue);
		sprintf(menu2.item[9].str[j], "  %9d   ", pinfo.oqueue);
	}
	return (0);
}

int getstatus(char *devname, int board, int box, int port)
{
	int	fd, i, j, idx;
	char	tmp[80];
	long	val;
	struct	termios		tty;
        struct mxser_mstatus    mstatus[MAX_PORT];
        struct moxaq_str        ioq[MAX_PORT];

	fd = open("/dev/moxa", O_RDWR);
	if ( fd < 0 )
	    return(-1);
            
	ioctl(fd, MOXA_GETMSTATUS, mstatus);
        idx = board * MAX_PORTS_PER_BOARD + box * MAX_PORTS_PER_BOARD + port;

        for(i=0;i<20;i++){
            if((mstatus[idx].cflag & (CBAUD | CBAUDEX) ) == BaudMapTab[i]){
                pinfo.baud = i;
                break;
            }
        }
	if (mstatus[idx].cflag & PARENB) {
		if (mstatus[idx].cflag & PARODD){
			if(mstatus[idx].cflag & CMSPAR)
				pinfo.parity = 3;
			else
				pinfo.parity = 1;
		}else{
			if(mstatus[idx].cflag & CMSPAR)
				pinfo.parity = 4;
			else
				pinfo.parity = 2;
		}
	} else
		pinfo.parity = 0;

	switch(mstatus[idx].cflag & CSIZE){
	    case CS5:
 		pinfo.databit = 0;
		break;
	    case CS6:
 		pinfo.databit = 1;
		break;
	    case CS7:
 		pinfo.databit = 2;
		break;
	    case CS8:
 		pinfo.databit = 3;
		break;
	}
	if (mstatus[idx].cflag & CSTOPB)
		pinfo.stopbit = 1;
	else
		pinfo.stopbit = 0;
		
	/* get DCD DSR...*/

	pinfo.CTS = mstatus[idx].cts;
	pinfo.DSR = mstatus[idx].dsr;
        pinfo.DCD = mstatus[idx].dcd;

	ioctl(fd, MOXA_GET_IOQUEUE, ioq);

	pinfo.iqueue = pinfo.oqueue = 0;

        pinfo.iqueue = ioq[idx].inq;
        pinfo.oqueue = ioq[idx].outq;

	close(fd);
        
	return (0);
}