sunlink.c

操作系统SunOS 4.1.3版本的源码

set_dcp_parms(load_kernal, attach_dcp)
int  *load_kernal;
int  *attach_dcp;
{

    func_name = "set_dcp_parms"; 
    TRACE_IN 
    switch (using_device->board) {
    case 'a':
	*load_kernal = load_dcp_a;
	load_dcp_a = FALSE;
	*attach_dcp = attach_a[using_device->int_port];
	attach_a[using_device->int_port] = FALSE;
	break;
    case 'b':
	*load_kernal = load_dcp_b;
	load_dcp_b = FALSE;
	*attach_dcp = attach_b[using_device->int_port];
	attach_b[using_device->int_port] = FALSE;
	break;
    case 'c':
	*load_kernal = load_dcp_c;
	load_dcp_c = FALSE;
	*attach_dcp = attach_c[using_device->int_port];
	attach_c[using_device->int_port] = FALSE;
	break;
    case 'd':
	*load_kernal = load_dcp_d;
	load_dcp_d = FALSE;
	*attach_dcp = attach_d[using_device->int_port];
	attach_d[using_device->int_port] = FALSE;
	break;
    }
    TRACE_OUT
}

/* ***************
 * load_dcp_kern
 * ***************/

/* Download the dcp kernal */

load_dcp_kern(load_kernal)
int  load_kernal;
{

    func_name = "load_dcp_kern"; 
    TRACE_IN 
    if (load_kernal) 
    {
	if (simulate_error == NO_LOAD)
	    sprintf(tmpbuf,
		    "/no/dcpload -b %c /usr/sunlink/dcp/dcpmon.image", 
	    	    using_device->board);
	else
	    sprintf(tmpbuf,
		 "/usr/sunlink/dcp/dcpload -b %c /usr/sunlink/dcp/dcpmon.image", 		 using_device->board);

	send_message(0, DEBUG, "Executing %s\n", tmpbuf);
	if (system(tmpbuf))
		couldnt_execute(NO_LOAD);
    }
    TRACE_OUT
}

/* ****************
 * init_dcp_chnel 
 * ****************/

/* Initialize the selected channel */

init_dcp_chnel(attach_dcp)
int  attach_dcp;
{

    func_name = "init_dcp_chnel"; 
    TRACE_IN 
    if (attach_dcp) 
    {
	if (simulate_error == NO_ATTACH)
	    sprintf(tmpbuf, "/no/dcpattach /dev/%s", using_device->device);
	else
	    sprintf(tmpbuf, "/usr/sunlink/dcp/dcpattach /dev/%s > /dev/null", using_device->device);

	send_message(0, DEBUG, "Executing %s\n", tmpbuf);
	if (system(tmpbuf))
		couldnt_execute(NO_ATTACH);
    }
    TRACE_OUT
}

/* ******************
 * config_dcp_chnel
 * ******************/

/* Configure selected channel to the selected protocol by dcplayer command */

config_dcp_chnel(attach_dcp)
int  attach_dcp;
{

    	func_name = "config_dcp_chnel"; 
    	TRACE_IN 
	if (attach_dcp) 
        {
	    if (simulate_error == NO_LAYER)
		sprintf(tmpbuf, "/no/dcplayer %s zss%c", using_device->device, using_device->port);
	    else
		sprintf(tmpbuf, "/usr/sunlink/dcp/dcplayer %s zss%c", 
                        using_device->device, using_device->port);

	    send_message(0, DEBUG, "Executing %s\n", tmpbuf);
	    if (system(tmpbuf))
		    couldnt_execute(NO_LAYER);
	}
        TRACE_OUT
}

/* ***************
 * init_brd_sdlc 
 * ***************/

/* Syncinit board thru driver */

init_brd_sdlc()
{

    	func_name = "init_brd_sdlc"; 
    	TRACE_IN 
	if (simulate_error == NO_SOCKET)
	    sock_type = 7;
	else
	    sock_type = SOCK_DGRAM;

/* Get socket for ioctl communication with driver */
	if ((using_device->s = socket(AF_INET, sock_type, 0)) < 0) 
 	{
	    perror("sunlink: socket, perror says");
	    send_message(-NO_SOCKET, ERROR, "Couldn't open a socket for '%s'.",
                    using_device->device);
	}
	if (simulate_error == NO_GETSYNC)
	    s = 0;

/* Set ifr_name to identify device driver for communication */
	strcpy(ifr.ifr_name, using_device->device);

/* Get current sync mode information */
	if (ioctl(using_device->s, SIOCGETSYNC, &ifr)) 
 	{
	    perror("sunlink: SIOCGETSYNC, perror says");
	    send_message(-NO_GETSYNC, ERROR, 
		"Couldn't get sync mode info for '%s'.", using_device->device);
	}
	if (debug) 
	{
	    if (simulate_error == NO_CHECK_SETSYNC)
		s = 0;
	    strcpy(ifr.ifr_name, using_device->device);
	    if (ioctl(using_device->s, SIOCGETSYNC, &ifr)) 
	    {
		    perror("sunlink: SIOCGETSYNC, perror says");
		    send_message(-NO_CHECK_SETSYNC, ERROR, 
				"Couldn't check SETSYNC for '%s'.",
                                using_device->device);
	    }
	}

	if (cur_test == DCP)
            set_sync_dcp();
        else
            if (cur_test == MCP)
                set_sync_mcp();
            else
		if ((its_his) || (its_hih))
                	set_sync_hih();
		else
                	set_sync_hss();

	send_message(0, DEBUG, "clock type = %c\n", clock_type);

	/*
	 * if (debug) { printf("txc=%s, rxc=%s\n", txc_mptr, rxc_mptr);
	 * printf("syncinit '%s' %d loopback=%s nrzi=%s txc=%s rxc=%s",
	 * using_device->device, baudrate, lb_mptr, nrzi_mptr, txc_mptr,
	 * rxc_mptr); sprintf(tmpbuf, "/usr/src/sunlink/inr/syncinit %s %d
	 * loopback=%s nrzi=%s txc=%s rxc=%s", using_device->device,
	 * baudrate, lb_mptr, nrzi_mptr, txc_mptr, rxc_mptr);
	 * printf("Executing %s\n", tmpbuf); system(tmpbuf); }
	 */

	if (simulate_error == NO_SETSYNC)
	    s = 0;

/* Set ifr_name to identify driver for communication */
	strcpy(ifr.ifr_name, using_device->device);

/* Set new sync mode information */ 
	if (ioctl(using_device->s, SIOCSETSYNC, &ifr)) {
	    perror("sunlink: SIOCSETSYNC, perror says");
	    send_message(-NO_SETSYNC, ERROR, 
		"Couldn't set sync mode info for '%s'.", using_device->device);
	}
	if (debug) 
   	{
	    if (simulate_error == NO_CHECK_SETSYNC)
		s = 0;
	    strcpy(ifr.ifr_name, using_device->device);
	    if (ioctl(using_device->s, SIOCGETSYNC, &ifr)) 
   	    {
		    perror("sunlink: SIOCGETSYNC, perror says");
		    send_message(-NO_CHECK_SETSYNC, ERROR, 
				"Couldn't check SETSYNC for '%s'.",
                                using_device->device);
	    }
	    printf
		("speed= %d, internal loopback= %s, nrzi= %s, txc= %s, rxc= %s\n",
	     ssm->sm_baudrate, yesno[ssm->sm_loopback], yesno[ssm->sm_nrzi],
		 txnames[ssm->sm_txclock], rxnames[ssm->sm_rxclock]);
	}
	strcpy(ifr.ifr_name, using_device->device);
        if (ioctl(using_device->s, SIOCGETSYNC, &ifr)) 
   	{
           perror("sunlink: SIOCGETSYNC, perror says");
           send_message(-NO_CHECK_SETSYNC, ERROR, 
			    "Couldn't check SETSYNC for '%s'.",
                            using_device->device);
        }
	TRACE_OUT
}

/* **************
 * set_sync_dcp
 * **************/

/* Set sync mode data for DCP testing */

set_sync_dcp()
{
    func_name = "set_sync_dcp"; 
    TRACE_IN 
    ssm->sm_baudrate = baudrate;
    ssm->sm_txclock = TXC_IS_BAUD;
    ssm->sm_rxclock = RXC_IS_BAUD;
    if (internal_loopback)
	ssm->sm_loopback = (char) 1;           /* do internal loopback */
    else {               		       /* clock_type=0 for int loopbk */
	lb_mptr = "no";
    	ssm->sm_loopback = (char) 0;
    }
    TRACE_OUT
}

/* **************
 * set_sync_mcp
 * **************/

/* Set sync mode data for MCP testing */

set_sync_mcp()
{
    func_name = "set_sync_mcp"; 
    TRACE_IN 
    ssm->sm_baudrate = baudrate;
    ssm->sm_txclock = TXC_IS_BAUD;
    ssm->sm_rxclock = RXC_IS_RXC;              /* use the loopback clock only
                                                * on mcp ports */
    if (internal_loopback)
	ssm->sm_loopback = (char) 1;           /* do internal loopback */
    else                 		       /* clock_type=0 for int loopbk */
    {
	lb_mptr = "no";
    	ssm->sm_loopback = (char) 0;
    }
    TRACE_OUT
}

/* **************
 * set_sync_hih
 * **************/

/* Set sync mode data (in ssm struct fields) for Sbus-HSI testing */
/* S-Bus HSI only uses the ssm (syncmode struct) structure and not */
/* the syncmode structure inside the hsm structure; therefore, */
/* values are only assigned to the ssm struct */

set_sync_hih()
{
    func_name = "set_sync_hih"; 
    TRACE_IN 
    ssm->sm_baudrate = 100000;   /* 100,000 kbits per sec */
				 /* could also be set to 2.048 Mbits per sec 
				    but may have some difficulties testing
				    more than one port at this speed */
    if (internal_loopback)	 /* S-Bus HSI only allows on-board clock */
    {				 /* source when running internal loopback */
	ssm->sm_loopback = YES;
        ssm->sm_txclock = TXC_IS_BAUD;   /* use on-board clock */
        ssm->sm_rxclock = RXC_IS_BAUD;  
    }
    else 
    {
        lb_mptr = "no";
        ssm->sm_loopback = NO;
        if (using_device->hp_obclk)          /* if using on-board clock source */ 
        {
            ssm->sm_txclock = TXC_IS_BAUD;
            ssm->sm_rxclock = RXC_IS_RXC;
        }
        else				     /* if using external clock source, */ 
        {				     /* user must physically loopback */
            ssm->sm_txclock = TXC_IS_TXC;    /* xmit & recv pins and provide */
            ssm->sm_rxclock = RXC_IS_RXC;    /* the external clock source */
        }
    }    
    TRACE_OUT
}

/* **************
 * set_sync_hss
 * **************/

/* Set sync mode data for HSS testing */

set_sync_hss()
{
    func_name = "set_sync_hss"; 
    TRACE_IN 
                                      /* set syncmode field of hss struct */
    ssm = (struct syncmode *)&hsm->hp_mode;
    hsm->hp_mode.sm_baudrate = 9600;  /* 2.048 Mbits per sec */
    hsm->hp_tpval = 0;			 /* poll time value */
    hsm->hp_fwm = 2;
    hsm->hp_burst = 2;
    if (using_device->hp_v35)
	hsm->hp_v35 = 1;
    else
	hsm->hp_v35 = 0;
    
    if (internal_loopback) 
	switch(loopback_type) {
	    case SIMPLE :
    		ssm->sm_loopback = YES;
		hsm->hp_lback = SIMPLE;	       /* assert loopback */
	    	hsm->hp_mode.sm_txclock = TXC_IS_BAUD;	 /* use onboard clock */
		hsm->hp_mode.sm_rxclock = RXC_IS_BAUD;
		break;
	    case CLOCKLESS :
		ssm->sm_loopback = YES;
		hsm->hp_lback = CLOCKLESS;
		hsm->hp_mode.sm_txclock = TXC_IS_SYSCLK; /* use sysclock */
		hsm->hp_mode.sm_rxclock = RXC_IS_SYSCLK;
		break;
	    case SILENT :
		ssm->sm_loopback = SLNT;
		hsm->hp_lback = SILENT;	       /* assert silent loopback */
    		hsm->hp_mode.sm_txclock = TXC_IS_BAUD;
		hsm->hp_mode.sm_rxclock = RXC_IS_BAUD;
                break;
            case SILENT_CLOCKLESS :
		ssm->sm_loopback = SLNT;
		hsm->hp_lback = SILENT_CLOCKLESS;
                hsm->hp_mode.sm_txclock = TXC_IS_SYSCLK;
                hsm->hp_mode.sm_rxclock = RXC_IS_SYSCLK;
                break; 
	}
    else 
    {
	hsm->hp_lback = NORMAL;
        lb_mptr = "no";
	ssm->sm_loopback = NO;
	if (using_device->hp_obclk) 
        {
	    hsm->hp_mode.sm_txclock = TXC_IS_BAUD;
	    hsm->hp_mode.sm_rxclock = RXC_IS_RXC;
	}
	else 
  	{
	    hsm->hp_mode.sm_txclock = TXC_IS_TXC;
	    hsm->hp_mode.sm_rxclock = RXC_IS_RXC;
	}
    }
    TRACE_OUT
}


/* **************
 * couldnt_execute
 * **************/

couldnt_execute(who)
int       who;
{
    char            file_name_buffer[30];
    char           *file_name = file_name_buffer;

    func_name = "couldnt_execute"; 
    TRACE_IN 
    switch (who) {
    case NO_LOAD:{
	    sprintf(file_name, "load' for dcp %c", using_device->board);
	    break;
	}
    case NO_ATTACH:{
	    sprintf(file_name, "attach' for '%s'", using_device->device);
	    break;
	}
    case NO_LAYER:
    case NO_LAYER_LOOPBACK:{
	    sprintf(file_name, "layer' for '%s'", using_device->device);
	}
    }

    send_message(-who, ERROR, 
	"Couldn't successfully execute '/usr/sunlink/dcp/dcp%s.", file_name);
    TRACE_OUT
}

/* **************
 * exercise_dcp
 * **************/

exercise_dcp()
{
    register        i, j, k, transmit_length, lp1;
    u_char         *sbufptr, *rbufptr;

    func_name = "exercise_dcp"; 
    TRACE_IN 
    sbufptr = sbarray;
    rbufptr = rbarray;
    frame_count = max_frame_len - min_frame_len + 1;
    if (simulate_error == WRITE_FAILED) 
    {
	flock(xmit_device->fid, LOCK_UN);	/* unlock file */
        close(xmit_device->fid);
    }
    if (simulate_error == READ_FAILED) 
    {
	flock(rec_device->fid, LOCK_UN);
        close(rec_device->fid);
    }

    for (lp1 = 1; lp1 <= loop_count; lp1++) 
    {
        transmit_length = min_frame_len;
	prepare_buffer();
	for (i = 0; i < frame_count; i++) 
        {
	    for (j = 0; j <= transmit_length; j++)  
	    {
		if (ttyb_test)
		    rbarray[j] = sbarray[j];
		else
		    rbarray[j] = 0;		/* prepare receive buffer */
	    }

	    line_check(rbufptr, transmit_length);
	    xmit_buf(sbufptr, transmit_length, i);
	    receive_buf(rbufptr, transmit_length);
	    compare_buf(sbufptr, rbufptr, transmit_length);
	    ++transmit_length;
	}
    }
    TRACE_OUT
}


/*
 *	line_check:  checks for any current activity on port
 */

line_check(rbufptr, transmit_length)
u_char  *rbufptr;
u_long  transmit_length;
{
        int readmask;
 
    	func_name = "line_check"; 
    	TRACE_IN 
        send_message(0, DEBUG, "Checking for activity on line.");
        readmask = 1 << rec_device->fid;
        while (select(32, &readmask, 0, 0, &short_time) == 1) 
        {
                (void) read(rec_device->fid, rbufptr, transmit_length);