mon.c

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

/*****************************************************************************/
/* MON.C                                                                     */
/*									     */
/* Copyright (c) Moxa Technologies Inc. 1999. All Rights Reserved.	     */
/*									     */
/* Revision history:							     */
/*	08/15/1996	Victor		wroted it.                           */
/*      8/5/99          Casper                                               */
/*****************************************************************************/


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

#define MAX_ROW		8
#define	SEARCH_START	0
#define SEARCH_UP	1
#define SEARCH_DOWN	2

#define	GETDATACOUNT	(MOXA + 23)

#define min(x,y)     ((x) < (y) ? (x) : (y))
#define ROWCNT(board) (min(Gmxcfg[board].numPorts , MAX_ROW))

moxa_board_conf Gmxcfg[MAX_BOARDS];

typedef struct C218320Mon_str {
	int	tick;
	int	rxcnt[MAX_PORT];
	int	txcnt[MAX_PORT];
}C218320Mon_t;

static int	interval;
static time_t	t1, t2, t3;
static char	mon_card;

static C218320Mon_t	c218320_slog_old, c218320_slog_s, c218320_slog_e;

static int	MonRowSpace[MON_TOTAL_ITEM] = { 10, 10, 8, 8, 10, 8, 8 };
static int	MonItemFlag[MON_TOTAL_ITEM] = {
	F_Return,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly,
	F_Readonly
};
static char	*MonItemDes[MON_TOTAL_ITEM] = {"", "", "", "", "", "", ""};
static struct	GEdit3	MonMenu3 = {
	Edit3Type0 | Edit3Type3 | Edit3Type5, -1, -1, MON_TOTAL_ITEM,
	0, 0, 0, 
	{"PgUp,PgDn:More Ports  Home:Reset Count  Esc:Exit  Enter:Port Status"},
	0
};
static char	*MonSubtDes[] = {
	"           ----------- Rx ------------- ----------- Tx ------------",
	" Device    Char Count  Throughput(BPS)  Char Count  Throughput(BPS)",
	"  name       (bytes)  Interval  Average   (bytes)  Interval  Average"
};
static  char    GTtyName[(MAX_PORTS_PER_BOARD * MAX_BOARDS)][30];
char	*szboard[] = {
        "",
        "C218 Turbo/PCI",
        "C218 Turbo",
        "C320 Turbo/PCI",
        "C320 Turbo",
        "CP-204J"
};

void	mon();

static int	init_menu(int board, int box);
static void	reset_count();
static void	show_timer(int board);
static void	flush_menu_data(int board, int box);
static void	init_device_name(int board, int box);
static int	search_start_port();

void mon(int all_boards)
{
	int	i, c, exit_flag=0, flag;
	int	need_prepare = 1, old_space_ndx;
	fd_set	rfdset;
	struct	timeval tm;

        int     board=0, box=0, oldboard;

	if ( search_start_port(SEARCH_START, &board, &box, all_boards) < 0 ) {
		confirm("Not any MOXA serial board is installedd !");
		return;
	}
	interval = 3;
	old_space_ndx = init_menu(board, box);
	mw_edit3init(&MonMenu3);
	for ( i=0; i<3; i++ ) {
		mw_wgotoxy(MonMenu3.wid, 1, i + 2);
		mw_wputsc(MonMenu3.wid, (uchar *)MonSubtDes[i], strlen(MonSubtDes[i]), 
			  MonMenu3.wid->norm_c);
	}
	tm.tv_sec = 1;
	tm.tv_usec = 0; 
	FD_ZERO(&rfdset);
	while (exit_flag == 0) {
		if (need_prepare) {
			flush_menu_data(board, box);
			edit3_flush_data(&MonMenu3);
			show_timer(board);
			need_prepare = 0;
		}
		FD_SET(tty_fd, &rfdset);
		select(tty_fd+1, &rfdset, NULL, NULL, &tm);
		switch (mw_edit3()) {
		case K_ESC:
			exit_flag = 1;
			break;
		case K_ENTER:
			c = MonMenu3.item[MonMenu3.act_item].act_item;
			if ( c == 0 )
				flag = MON_TOP;
			else if ( c == (ROWCNT(board) - 1) )
				flag = MON_BOTTOM;
			else
				flag = MON_NORMAL;
			while ( (i=mon_pa_setup(MonMenu3.item[0].str[c], 
				interval, flag, board, box, c)) != 0 ){
				if (i < 0 && c > 0)
					c--;
				if (i > 0 && c < ROWCNT(board) - 1)
					c++;
				if ( c == 0 )
					flag = MON_TOP;
				else if ( c == (ROWCNT(board) - 1) )
					flag = MON_BOTTOM;
				else
					flag = MON_NORMAL;
			}	
			MonMenu3.item[MonMenu3.act_item].act_item = c;
			need_prepare = 1;
			break;
		case '+':
			if (interval < MAX_CNT_TIME)
				interval++;
			show_timer(board);
			break;
		case '-':
			if (interval > MIN_CNT_TIME)
				interval--;
			show_timer(board);
			break;
		case K_HOME :
			reset_count();
			need_prepare = 1;
			break;
		case K_PGUP :
                        oldboard = board;
			if ( search_start_port(SEARCH_UP, &board, &box, all_boards) < 0 )
				break;
                        if(board != oldboard){
                           release_space(old_space_ndx);
                           mw_edit3end();
	                   old_space_ndx = init_menu(board, box);
	                   mw_edit3init(&MonMenu3);
	                   for ( i=0; i<3; i++ ) {
		               mw_wgotoxy(MonMenu3.wid, 1, i + 2);
		               mw_wputsc(MonMenu3.wid, (uchar *)MonSubtDes[i], strlen(MonSubtDes[i]),
			           MonMenu3.wid->norm_c);
                           }
                        }
                        
			init_device_name(board, box);
			reset_count();
			need_prepare = 1;
			break;
		case K_PGDOWN :
                        oldboard = board;
			if ( search_start_port(SEARCH_DOWN, &board, &box, all_boards) < 0 )
				break;
                        if(board != oldboard){
                           release_space(old_space_ndx);
                           mw_edit3end();
	                   old_space_ndx = init_menu(board, box);
	                   mw_edit3init(&MonMenu3);
	                   for ( i=0; i<3; i++ ) {
		               mw_wgotoxy(MonMenu3.wid, 1, i + 2);
		               mw_wputsc(MonMenu3.wid, (uchar *)MonSubtDes[i], strlen(MonSubtDes[i]),
			           MonMenu3.wid->norm_c);
                           }
                        }
                                
			init_device_name(board, box);
			reset_count();
			need_prepare = 1;
			break;
		default:
			if (time((time_t *)&t3) - t2 < interval)
				break;
			need_prepare = 1;
			break;
		}
	}
	release_space(old_space_ndx);
	mw_edit3end();
}

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

	reset_count();
	old_space_ndx = get_space_ndx();
	j = sizeof(struct GItem3) * MON_TOTAL_ITEM;
	MonMenu3.item = (struct GItem3 *)get_space(j);
	MonMenu3.x = 5;
	MonMenu3.y = 5;
	for (i = 0; i < MON_TOTAL_ITEM; i++) {
		MonMenu3.item[i].flag = MonItemFlag[i];
		MonMenu3.item[i].des = MonItemDes[i];
		MonMenu3.item[i].act_item = 0;
		MonMenu3.item[i].total = ROWCNT(board);
		for (j = 0; j < MonMenu3.item[i].total; j++) {
			MonMenu3.item[i].len[j] = MonRowSpace[i];
			MonMenu3.item[i].str[j] = get_space(MonRowSpace[i] + 1);
			for (k = 0; k < MonRowSpace[i]; k++)
				MonMenu3.item[i].str[j][k] = ' ';
			MonMenu3.item[i].str[j][k] = 0;
		}
	}
	MonMenu3.act_item = 1;
	init_device_name(board, box);
	return(old_space_ndx);
}

static void init_device_name(int board, int box)
{
	int	i, j, k;

	for ( j=0; j<ROWCNT(board); j++ ) {
		sprintf(MonMenu3.item[0].str[j], "%-10s",
                    GTtyName[(board*MAX_PORTS_PER_BOARD)+(box*MAX_PORTS_PER_BOX) + j]);
	}
}

static void flush_menu_data(int board, int box)
{
	int			i, j, b;

	getdatacnt(&c218320_slog_e);
	t2 = time((time_t *)&t3);
	for ( j=0; j<ROWCNT(board); j++ ) {
                i = (board*MAX_PORTS_PER_BOARD) + (box*MAX_PORTS_PER_BOX) +j;
		b = t2 - t1;
		if (b == 0)
			b = 1;
		sprintf(MonMenu3.item[1].str[j], "%10d",
                    c218320_slog_e.rxcnt[i] - c218320_slog_old.rxcnt[i]);
		sprintf(MonMenu3.item[2].str[j], "%8d",
                    (c218320_slog_e.rxcnt[i] - c218320_slog_s.rxcnt[i]) / interval);
		sprintf(MonMenu3.item[3].str[j], "%8d",
                    (c218320_slog_e.rxcnt[i] - c218320_slog_old.rxcnt[i]) / b);
		sprintf(MonMenu3.item[4].str[j], "%10d",
                    c218320_slog_e.txcnt[i] - c218320_slog_old.txcnt[i]);
		sprintf(MonMenu3.item[5].str[j], "%8d",
                    (c218320_slog_e.txcnt[i] - c218320_slog_s.txcnt[i]) / interval);
		sprintf(MonMenu3.item[6].str[j], "%8d",
                    (c218320_slog_e.txcnt[i] - c218320_slog_old.txcnt[i]) / b);
        }
	c218320_slog_s = c218320_slog_e;
}

int getdatacnt(C218320Mon_t *logdata)
{
	int	fd, i;
        int     ret;

	if ( (fd=open("/dev/moxa", O_RDWR)) < 0 )
		return(-1);
	
        
	ret = ioctl(fd, GETDATACOUNT, logdata);
        
	close(fd);
	return (0);
}

static void show_timer(int board)
{
	char	tmp[80], str[40];
	time_t	i;
	int	hr, min, sec, j, w;

	i = time((time_t *)&t3) - t1;
	sec = i % 60;
	min = i / 60;
	hr = min / 60;
	min = min % 60;

	mw_wcolor(MonMenu3.wid, D_A_Normal);
	sprintf(str, " Board #%d Type:%s",
		board+1, szboard[Gmxcfg[board].boardType]);

	w = MonMenu3.wid->w - 2;
	for ( i=0; i<w; i++ )
		tmp[i] = ' ';
	tmp[i] = 0;
	mw_wcputs(MonMenu3.wid, 1, (uchar *)tmp);
	sprintf(tmp, "Time[%02d:%02d:%02d]%-32s Interval %d sec <+/->", 
		hr, min, sec, str, interval); 
	mw_wcputs(MonMenu3.wid, 1, (uchar *)tmp);
}

static void reset_count()
{
	getdatacnt(&c218320_slog_old);
	c218320_slog_s = c218320_slog_old;
        
	t1 = time((time_t *)&t3);
}

static int search_start_port(int flag, int *board, int *box, int boards)
{
	int	i, card, sport, pno, ctype;
        int     old_box;

	switch ( flag ) {
	case SEARCH_START :
                *board = 0;
                *box = 0;
                return 1;
		break;
	case SEARCH_UP :
                if(*box==0){
                    if(*board==0)
                        return -1;
                    else
                       (*board)--;
                    *box = Gmxcfg[*board].numPorts / MAX_PORTS_PER_BOX;
                    if(*box)
                        (*box)--; //for which not cp-204j

                }else
                    (*box)--;
                return 1;
	case SEARCH_DOWN :
                old_box = Gmxcfg[*board].numPorts / MAX_PORTS_PER_BOX;
                if(old_box)
                    old_box--; //for which not cp-204j

                if(*box==old_box){
                    if(*board== boards-1)
                        return -1;
                    else{
                        (*board)++;
                        *box = 0;
                    }
                }else
                    (*box)++;
                return 1;
	}	
	return(-1);
}


void read_tty(int now_major)
{
        FILE    *fd;
        char    ttystr[40];
        char    s1[20],s2[20],s3[20],s4[20],s7[20],s8[20],s9[20];
        char    tmp[100];
        int     major, minor;
        int     i,ch;

        for(i=0; i<(MAX_PORTS_PER_BOARD * MAX_BOARDS); i++){
            sprintf(GTtyName[i], "port %d", i+1);
        }

        sprintf(tmp, "ls -al /dev | grep %d > /tmp/mon.tmp 2> /dev/null",
                     now_major);

        system(tmp);

        fd = fopen("/tmp/mon.tmp", "r");

        do{
            i = 0;
            do{
                ch = fgetc(fd);
                if((ch==-1) || (ch=='\n')){
                    tmp[i] = 0;
                    break;
                }else{
                    tmp[i++] = ch;
                }
            }while(1);
            if(ch==-1)
                break;
            sscanf(tmp,"%s %s %s %s %d, %d %s %s %s %s",
                      s1,s2,s3,s4,&major,&minor,s7,s8,s9,ttystr);
            if(s1[0] != 'c')
                continue;
            if(major!=now_major)
                continue;
            if(major>=(MAX_PORTS_PER_BOARD * MAX_BOARDS))
                continue;

            if(strlen(ttystr) >= 10)
                ttystr[9] = 0;
            strcpy(GTtyName[minor], ttystr);
        }while(1);
        fclose(fd);
        system("rm -f /tmp/mon.tmp 2> /dev/null");
}



void main_end()
{
	mw_wend();
}

int main()
{
	int	fd, ret;
        int     i;
        int     boards;
        int     major;
        
	if((fd = open("/dev/moxa", O_RDWR)) < 0){
	    printf("open /dev/moxa fail\n");
	    return;
	}

	ret = ioctl(fd, MOXA_GET_CONF, Gmxcfg);
	if(ret != 0){
	    printf("ioctl fail,ret=%d\n",ret);
	    return;
	}
	ioctl(fd, MOXA_GET_MAJOR, &major);
	close(fd);

        read_tty(major);
        
        boards = 0;
	for(i=0; i<MAX_BOARDS; i++){
	    if(Gmxcfg[i].boardType!=0)
                boards++;
	}
	if(!boards){
	    printf("No any MOXA Intellio Family board installed.\n");
	    return 1;
	}

	space_init();	
	mw_winit();
        
	mon(boards);
	
	mw_wend();

        return 0;
}