dptarget.c

VXWORKS源代码

        /* advance the read pointer */
        if(bp->flags & DPMSG_WRAP) {
            cp->rx = cp->rxbase;
        } else {
            cp->rx += DPM_MSGSIZE;
        }

        /* see if there are more messages waiting */
        if(cp->rx == cp->rxlim) {
            cp->rx = (-1);
        }
    }

    /* extract the character */
    ch = (unsigned int) bp->buf[bp->index++];

    /* check whether we finished the buffer */
    if(bp->index == bp->bufsize) {
        /* invalidate the buffer */
        bp->index = (-1);
    }

    return(ch);
}


/* send a message to netrom */
void
chan_putmsg(chan, buf, len)
int chan;
uChar *buf;
register int len;
{
    register DpChannel *cp = &channels[chan];
    register int num_sent = 0;
    int size, num_left = len, ovf_size;
    volatile uChar dummy;
    register uInt16 flags;

    while(num_sent < len) {
        /* wait for the buffer */
        while(1) {
            flags = dp_readint(cp->tx + DPM_FLAGS);

            if(flags != dp_readint(cp->tx + DPM_FLAGS)) {
                /* read failed on the verify, NetROM must be writing */
                continue;
            }
            if((flags & DPMSG_READY) == 0) 
                break;
#ifdef DUMMY_READ
	    dummy = READ_POD(cp, RA_ACK+8 );
#endif
            YIELD_CPU(); 
        }

	/* get the number of bytes to send in DP struct and overflow */
	if(num_left >= DP_DATA_SIZE) {
	    size = DP_DATA_SIZE;
	    if (num_left >= MAX_MSG_SIZE)
               	ovf_size = MAX_OVF_MSG_SIZE;
	    else
               	ovf_size = num_left - DP_DATA_SIZE;
	} else {
	    size = num_left;
            ovf_size = 0;
	}

	/* fill the currently available DP buffer */
	/* Put full msg size in upper bits of first size field */
	if (num_sent == 0) { 
	    dp_writeint(cp->tx + DPM_SIZE, (len << 6) | size);
	} else
	    dp_writeint(cp->tx + DPM_SIZE, size); 

	dp_bwrite(buf, cp->tx + DPM_DATA, size);

	/* get the flags to write */
	flags = (flags & DPMSG_WRAP) | DPMSG_READY;
	if(num_sent == 0) {
            flags |= DPMSG_START;
	    /* or in 1K bit of msg len */
	    flags =  flags | (len & DPMSG_1K_BIT); 
	}
	num_sent += size;
	num_left -= size;

	if(num_sent >= len) 
            flags |= DPMSG_END;
	dp_writeint(cp->tx + DPM_FLAGS, flags);
	dp_writeint(cp->tx + DPM_FLAGS, flags); /* try writing it twice */

	/* notify NetROM that the buffer is ready */
	dummy = READ_POD(cp, READADDR_CTLCHAR(cp , RW_MRI));

	/* adjust pointers */
	buf += size;

	/* advance the msg pointer */
	if(flags & DPMSG_WRAP) {
	    cp->tx    = cp->txbase;
	    cp->txovf = cp->txovfbase;
	} else {
	    cp->tx    += DPM_MSGSIZE;
	    cp->txovf += MAX_OVF_MSG_SIZE;
	}
    }
}


/* flush the current character-oriented tx channel */
void
chan_flushtx(chan)
int chan;
{
    DpChannel *cp = &channels[chan];
    BufIo *bp = &cp->txbuf;
    volatile uChar dummy;

    /* if we don't own the message or there's nothing in it, just return */
    bp->flags = dp_readint(cp->tx + DPM_FLAGS);
    if((bp->flags & DPMSG_READY) != 0 || bp->index == 0) {
        return;
    }

    /* send the buffer */
    dp_writeint(cp->tx + DPM_SIZE, (uInt16)bp->bufsize);
    dp_bwrite(bp->buf, cp->tx + DPM_DATA, (int) bp->bufsize);
    bp->flags &= DPMSG_WRAP;
    dp_writeint(cp->tx + DPM_FLAGS,
        (uInt16)bp->flags | (DPMSG_READY|DPMSG_START|DPMSG_END));

    /* notify NetROM that the buffer is ready */
    dummy = READ_POD(cp, READADDR_CTLCHAR(cp, RW_MRI));

    /* advance the msg pointer */
    if(bp->flags & DPMSG_WRAP) {
        cp->tx = cp->txbase;
    } else {
        cp->tx += DPM_MSGSIZE;
    }

    /* clear the buffer structure */
    bp->index = 0;
    bp->bufsize = 0;
}

int
chan_putch(chan, ch)
int chan;
uChar ch;
/*
	Write a character into the transmit area of the readwrite
	channel.
*/
{
    DpChannel *cp = &channels[chan];
    BufIo *bp = &cp->txbuf;

    /* if the current tx channel is owned by the target, wait for it */
    bp->flags = dp_readint(cp->tx + DPM_FLAGS);
    if(bp->flags & DPMSG_READY) {
        /* wait for the buffer */
        while(1) {
            bp->flags = dp_readint(cp->tx + DPM_FLAGS);
            if(bp->flags != dp_readint(cp->tx + DPM_FLAGS)) {
                /* read failed on the verify, NetROM must be writing */
                continue;
            }
            if((bp->flags & DPMSG_READY) == 0) break;
            if(cp->chanflags & CF_NOWAITIO) return(-1);
            YIELD_CPU();
        }

        /* initialize the buffer structure */
        bp->index = 0;
        bp->bufsize = 0;
    }

    /* write the character into the buffer */
    bp->buf[bp->index++] = ch;
    bp->bufsize++;

    /* if the buffer is full, send it */
    if(bp->index == DP_DATA_SIZE) {
        chan_flushtx(chan);
    }

    return(1);
}
#endif /* USE_MSGS */
#endif	/* READWRITE_TARGET */

#ifndef RAWRITES_ONLY

/* check if a character is waiting at the channel */
int
chan_kbhit(chan)
int chan;
{
    DpChannel *cp = &channels[chan];
    BufIo *bp = &cp->rxbuf;
    int retval;

    /* see if there is a character in this buffer */
    if(bp->index < 0) {
        /* poll for new buffers */
	if(cp->chanflags & CF_TXVALID)
        	c_dpcons_hdlr(chan,RW_MSGBASE);
	else
        	c_dpcons_hdlr(chan,RA_MSGBASE);

        /* no, check for a new buffer arriving */
        if(cp->rx != (-1)) {
            retval = 1;
        } else {
            retval = 0;
        }
    } else {
        retval = 1;
    }

    return(retval);
}

#endif	/* ! RAWRITES_ONLY */

/* returns 1 if the "active" byte for a particular channel's transmit
 * and/or receive paths are set, returns 0 otherwise */
int
dp_chanready(chan)
int chan;
{
    DpChannel *cp = &channels[chan];
    uChar val;

    if(cp->chanflags & CF_TXVALID) {
        /* check that the rx channel is active */
        val = READ_POD(cp, RW_RX);
        if(val != READ_POD(cp, RW_RX)) {
            return(0);
        } else if(val != 1) {
            return(0);
        }

        /* check that the tx channel is active */
        val = READ_POD(cp, RW_TX);
        if(val != READ_POD(cp, RW_TX)){
            return(0);
        } else if(val != 1) {
            return(0);
        }
    } else {
        /* check that the NetROM is ready for interrupts */
        val = READ_POD(cp, RA_RI);
        if(val != 1 || val != READ_POD(cp, RA_RI)) {
            /* NetROM is not receiving */
            return(0);
        }
    }

    /* NetROM is ready */
    return(1);
}

#ifndef RAWRITES_ONLY
/* if the CF_NOWAITIO bit is set in a channel's flags, the channel's get
 * and put character methods, will return immediately if there are no
 * available message structures in dualport ram.  This routine sets or
 * clears that bit. */
void
set_dp_blockio(chan, val)
int chan, val;
{
    DpChannel *cp = &channels[chan];

    if(val == 0) {
        cp->chanflags |= CF_NOWAITIO;
    } else {
        cp->chanflags &= ~CF_NOWAITIO;
    }
}

/* This routine handles any messages received from NetROM. */
STATIC void 
c_dpcons_hdlr(chan,base)
int chan;
uInt32 base;
{
    register DpChannel *cp;
    register uInt16 flags;
    /* volatile uChar dummy; */

    /* get a pointer to the channel */
    cp = &channels[0];

    /* a received message indicator */
    while(cp->rx != cp->rxlim) {
        flags = dp_readint(cp->rxlim + DPM_FLAGS);
        if(flags != dp_readint(cp->rxlim + DPM_FLAGS)) {
                /* NetROM must be writing, try again */
                continue;
        }

        if(flags & DPMSG_READY) {
            /* a new message is ready */
            if(cp->rx == (-1)) {
                /* record that the message is ready to be read */
                cp->rx = cp->rxlim;
            }

            /* advance the read limit pointer */
            if(flags & DPMSG_WRAP) {
                cp->rxlim = cp->rxbase;
            } else {
                cp->rxlim += DPM_MSGSIZE;
            }

	    /* process one message at a time if using readaddr protocol */
	    if((cp->chanflags & CF_TXVALID) == 0) {
		break;
	    }
        } else {
            /* no more messages */
            break;
        }
    }
}
#endif	/* ! RAWRITES_ONLY */


/* configure the dual-port ram to be used in a read-only or a read-write
 * fashion. */
int
config_dpram(base, width, index, flags, numaccesses)
uInt32 base;
int width, index, flags, numaccesses;
{
    DpChannel *cp = &channels[0];

    /* set the address of dualport ram in pod 0 */
    cp->dpbase = base;
    cp->width = width;
    cp->index = index;

    /* initialize the buffer system */
    cp->txbuf.bufsize = 0;
    cp->txbuf.index = 0;
    cp->rxbuf.bufsize = 0;
    cp->rxbuf.index = (-1);
    cp->numaccess = numaccesses;

    /* initialize the ack counter */
    cp->rxackval = 0;

    /* use the flags to set up */
    switch(flags) {
#ifdef READONLY_TARGET
    case DPF_READONLY_TGT:
        /* we can only read dualport */
        cp->chanflags = CF_RXVALID | CF_NOWAITIO;

        /* start the receive area after the read-address area, and the
         * status/control area */
        cp->rxbase = cp->rxlim = RA_MSGBASE;
        cp->rx = (-1);

	/* to avoid runtime divides, make this a case stmt */
	switch(cp->numaccess) {
	  case 4:
	    cp->oobthresh = (READADDR_SIZE / 4) - RA_MAX_INDEX;
	    break;
	  case 2:
	    cp->oobthresh = (READADDR_SIZE / 2) - RA_MAX_INDEX;
	    break;
	  case 1:
	  default:
	    cp->oobthresh = (READADDR_SIZE / 1) - RA_MAX_INDEX;
	    break;
	}
	/* Original code with the divide
	cp->oobthresh = (READADDR_SIZE / cp->numaccess) - RA_MAX_INDEX; */

        /* all done */
        break;
#endif	/* READONLY_TARGET */

#ifdef READWRITE_TARGET
    case DPF_ONECHANNEL:
        /* we can both read and write dualport */
        cp->chanflags = CF_TXVALID | CF_RXVALID | CF_NOWAITIO;

        /* start the receive area after the status/control area */
        cp->rxbase = cp->rxlim = RW_MSGBASE;
        cp->rx = (-1);

        /* start the transmit area after the receive area */
        cp->txbase = cp->tx = (RW_REC_MSGS + 1) * DPM_MSGSIZE;
	cp->oobthresh = 0;

        /* all done */
        break;
#endif	/* READWRITE_TARGET */
    
    default:
        return(-1);
        break;
    }

    return(0);
}