st16c554sio.c

vxworks下的16c554驱动

        mask = ((*pChan->inByte) (pChan->msr)) & ST16C554_MSR_CTS;


        /* if the CTS is asserted enable Tx interrupt */


        if (mask & ST16C554_MSR_CTS)
                ier |= ST16C554_IER_TBE;
        else
                ier &= (~ST16C554_IER_TBE); 


        }
    else 
        ier &= ~ST16C554_IER_MSI; /* disable modem status interrupt */ 


    oldlevel = intLock ();


    (*pChan->outByte) (pChan->lcr, lcr);
    (*pChan->outByte) (pChan->mdc, mcr);


    /* now clear the port */

    (*pChan->inByte) (pChan->data);


    if (options & CREAD)  
        ier |= ST16C554_IER_RXRDY;


    if (pChan->channelMode == SIO_MODE_INT)
        {
        (*pChan->outByte) (pChan->ier, ier);
        }


    intUnlock (oldlevel);


    pChan->options = options;


    return OK;
    }

/*******************************************************************************
*
* ST16C554Ioctl - special device control
*
* Includes commands to get/set baud rate, mode(INT, POLL), hardware options(
* parity, number of data bits), and modem control(RTS/CTS and DTR/DSR).
* The ioctl commands SIO_HUP and SIO_OPEN are implemented to provide the 
* HUPCL( hang up on last close) function.
*
* RETURNS: OK on success, EIO on device error, ENOSYS on unsupported
*          request.
*/
static int ST16C554Ioctl
    (
    ST16C554_CHAN *  pChan,        /* device to control */
    int request,                /* request code */
    int arg                     /* some argument */
    )
    {
    int test_ier;
    int ix;
    int baudH;
    int baudL;
    int oldlevel;
    UINT8 lcr;
    int status = OK;


    switch (request)
        {
        case SIO_BAUD_SET:
            status = (ST16C554BaudSet(pChan, arg) == OK) ? OK : EIO;
            break;


        case SIO_BAUD_GET:
            
            oldlevel = intLock();


            status = EIO;

            lcr = (*pChan->inByte) (pChan->lcr);
            (*pChan->outByte) (pChan->lcr, (char)( lcr));
            baudH = (*pChan->inByte)(pChan->brdh);
            baudL = (*pChan->inByte)(pChan->brdl);
            (*pChan->outByte) (pChan->lcr, lcr);


            for (ix = 0; ix < NELEMENTS (baudTable); ix++)
                {
                if ( baudH  == MSB (baudTable[ix].preset) &&
                     baudL  == LSB (baudTable[ix].preset) )
                    {
                    *(int *)arg = baudTable[ix].rate;
                    status = OK;
                    }
                }


            intUnlock(oldlevel);
            break;



        case SIO_MODE_SET:
            status = (ST16C554ModeSet (pChan, arg) == OK) ? OK : EIO;
            break;


        case SIO_MODE_GET:
            *(int *)arg = pChan->channelMode;
            return (OK);


        case SIO_AVAIL_MODES_GET:
            *(int *)arg = SIO_MODE_INT | SIO_MODE_POLL;
            return (OK);


        case SIO_HW_OPTS_SET:
            status = (ST16C554OptsSet (pChan, arg) == OK) ? OK : EIO;
            break;


        case SIO_HW_OPTS_GET:
            *(int *)arg = pChan->options;
            break;


        case SIO_HUP:
            /* check if hupcl option is enabled */


            if (pChan->options & HUPCL) 
                status = ST16C554Hup (pChan);
            break;
        
        case SIO_OPEN:
            /* check if hupcl option is enabled */


            if (pChan->options & HUPCL) 
                status = ST16C554Open (pChan);
            break;

	case SIO_INIT_IER:
	    (*pChan->outByte) (pChan->ier, ST16C554_IER_RXRDY);
	    test_ier = (*pChan->inByte)(pChan->ier);
	    printf("\nier=%d",test_ier);
	    
	    (*pChan->outByte) (pChan->fcr, 0x00);
	    test_ier = (*pChan->inByte)(pChan->fcr);
	    printf("\nfcr=%d",test_ier);
	    
	    test_ier = (*pChan->inByte)(pChan->mdc);
	    printf("\nMCR=%d",test_ier);
	    
	    test_ier = (*pChan->inByte)(pChan->msr);
	    printf("\nmsr=%d",test_ier);
	    
	    test_ier = (*pChan->inByte)(pChan->lst);
	    printf("\nlst=%d",test_ier);
	    
	    test_ier = (*pChan->inByte)(pChan->data);
	    printf("\ndata=%d",test_ier);
	    break;
	    
        default:
            status = ENOSYS;
            break;
        }


    return (status);
    }

/*******************************************************************************
*
* ST16C554Int - handle a receiver/transmitter interrupt
*
* This routine handles four sources of interrupts from the UART.  If there is
* another character to be transmitted, the character is sent.  When a modem
* status interrupt occurs, the transmit interrupt is enabled if the CTS signal
* is TRUE.
*
* INTERNAL
* The UART interrupts are prioritized in the following order by the Interrupt
* Identification Register:
*
*     Bit 2    bit 1    bit 0    Priority        Interrupt ID
*     -------------------------------------------------------
*     0        0        1        none            none
*     1        1        0        0               serialization error or BREAK
*     1        0        0        1               received data
*     0        1        0        2               transmitter buffer empty
*     0        0        0        3               RS-232 input
*
*
*
* In the table, priority level 0 is the highest priority.  These priorities
* are not typically configurable via software.  The interrupt is expressed as
* a two-bit integer.  Bit 0, the pending bit, is negative logic - a value 0
* means that an interrupt is pending.
*
* When nested interrupts occur, the second interrupt is identified in the
* Interrupt Identification Register (IIR) as soon as the first interrupt is
* cleared. Therefore, the interrupt service routine must continue to read IIR
* until bit-0 is 1.
*
* When the 8250 generates an interrupt, all interrupts with an equal or
* lower priority are locked out until the current interrupt has been cleared.
* The operation required to clear an interrupt varies according to the source.
* The actions typically required to clear an interrupt are as follows:
*
*    Source of interrupt                Response required to reset
*    ---------------------------------------------------------------------
*    receiver error or BREAK            read serialization status register
*    received data                      read data from receiver register
*    transmit buffer empty              write to the transmitter or read
*                                       the interrupt ID register
*    RS-232 input                       read the RS-232 status register
*
* In response to an empty transmit buffer (TBE), the interrupt can be
* cleared by writing a byte to the transmitter buffer register.  It can
* also be cleared by reading the interrupt identification register.
*
* Failure to clear all interrupts before returning will leave an interrupt
* pending and prevent the UART from generating further interrupt requests
* to the CPU.
*
* RETURNS: N/A
*/
void ST16C554Int
    (
    ST16C554_CHAN  *  pChan
    )
    {
    char outChar;       /* store a byte for transmission */
    char interruptID;   /* store contents of interrupt ID register */
    char lineStatus;    /* store contents of line status register */
    char ier;           /* store contents of interrupt enable register */
    char rec_data;
    int  ix = 0;        /* allows us to return just in case IP never clears */

    ier = (*pChan->inByte) (pChan->ier);

    /* service UART interrupts until IP bit set or read counter expires */

    FOREVER
        {
        interruptID = ((*pChan->inByte)(pChan->iid) & ST16C554_IIR_MASK);

	/*printf("\nafter int id=%d",interruptID);
        printf("\nafter int ix=%d",ix);*/
        
        if ((interruptID == ST16C554_IIR_IP) || (++ix > ST16C554_IIR_READ_MAX))
            {
            break;  /* interrupt cleared or loop counter expired */ 
            }


        /* filter possible anomalous interrupt ID from PC87307VUL (SPR 26117) */

        interruptID &= 0x0e;  /* clear odd-bit to find interrupt ID */


        if (interruptID == ST16C554_IIR_SEOB)
            {
            lineStatus = (*pChan->inByte) (pChan->lst);
            }
        else if (interruptID == ST16C554_IIR_RBRF)
            {
            
            if (pChan->putRcvChar != NULL)
              {
              	  
              	  (*pChan->putRcvChar)(pChan->putRcvArg,
                               (*pChan->inByte) (pChan->data));
              }
            else
              {
                (*pChan->inByte) (pChan->data);
                
              }
            /*printf("\nafter int id=%d",interruptID);*/
            }
        else if (interruptID == ST16C554_IIR_THRE)
            {
            if ((pChan->getTxChar != NULL) &&
                (*pChan->getTxChar) (pChan->getTxArg, &outChar) == OK
               )
                {
                (*pChan->outByte) (pChan->data, outChar);
                }

            /* There are no bytes available for transmission.  Reading
             * the IIR at the top of this loop will clear the interrupt.
             */

            }
        else if (interruptID == ST16C554_IIR_MSTAT) /* modem status register */
            {
            
            char msr = (*(pChan)->inByte) (pChan->msr);
	    printf("\ninterrupt msr!");
            /* (|=) ... DON'T CLOBBER BITS ALREADY SET IN THE IER */

            ier |= (ST16C554_IER_RXRDY | ST16C554_IER_MSI);

            /* if CTS is asserted by modem, enable tx interrupt */

            if ((msr & ST16C554_MSR_CTS) && (msr & ST16C554_MSR_DCTS))
                {
                (*pChan->outByte) (pChan->ier, (ST16C554_IER_TBE | ier));
                }
            else  /* turn off TBE interrupt until CTS from modem */
                {
                (*pChan->outByte) (pChan->ier, (ier & (~ST16C554_IER_TBE)));
                }
            }
	 /*
         else if(interruptID == ST16C554_IIR_TOUT)  receive data time out 
             {
             	
             }
        */
	
        }  /* FOREVER */
    }

/*******************************************************************************
*
* ST16C554Startup - transmitter startup routine
*
* Call interrupt level character output routine and enable interrupt if it is
* in interrupt mode with no hardware flow control.
* If the option for hardware flow control is enabled and CTS is set TRUE,
* then the Tx interrupt is enabled.
*
* RETURNS: OK
*/
LOCAL int ST16C554Startup
    (
    ST16C554_CHAN *  pChan         /* tty device to start up */
    )
    {
    char  ier = ST16C554_IER_RXRDY;
    char  mask;


    if (pChan->channelMode == SIO_MODE_INT)
        {
        if (pChan->options & CLOCAL)
            {
            /* No modem control */


            ier |= ST16C554_IER_TBE;
            }
        else
            {
            mask = ((*pChan->inByte) (pChan->msr)) & ST16C554_MSR_CTS;


            /* if the CTS is asserted enable Tx interrupt */


            if (mask & ST16C554_MSR_CTS)
                ier |= (ST16C554_IER_TBE | ST16C554_IER_MSI);
            else
                ier |= (ST16C554_IER_MSI);
            }


        (*pChan->outByte) (pChan->ier, ier);
        }


    return (OK);
    }

/******************************************************************************
*
* ST16C554PRxChar - poll the device for input.
*
* RETURNS: OK if a character arrived, EIO on device error, EAGAIN
* if the input buffer if empty.
*/
LOCAL int ST16C554PRxChar
    (
    ST16C554_CHAN *    pChan,      /* pointer to channel */
    char *          pChar       /* pointer to char */
    )
    {
    char pollStatus;


    pollStatus = ( *(pChan)->inByte) (pChan->lst);


    if ((pollStatus & ST16C554_LSR_RXRDY) == 0x00)
        return (EAGAIN);


    /* got a character */


    *pChar = ( *(pChan)->inByte) (pChan->data);

    printf("\npoll the device for input!");
    return (OK);
    }

/******************************************************************************
*
* ST16C554PTxChar - output a character in polled mode.
* 
* Checks if the transmitter is empty. If empty, a character is written to
* the data register. 
*
* If the hardware flow control is enabled the handshake signal CTS has to be
* asserted in order to send a character.
*
* RETURNS: OK if a character arrived, EIO on device error, EAGAIN
* if the output buffer if full.
*/
LOCAL int ST16C554PTxChar
    (
    ST16C554_CHAN *  pChan,        /* pointer to channel */
    char          outChar       /* char to send */
    )
    {
    char pollStatus;
    char msr;


    pollStatus = ( *(pChan)->inByte) (pChan->lst);


    msr = (*(pChan)->inByte) (pChan->msr);


    /* is the transmitter ready to accept a character? */


    if ((pollStatus & ST16C554_LSR_TEMT) == 0x00)
        return (EAGAIN);


    if (!(pChan->options & CLOCAL))      /* modem flow control ? */
        {
        if (msr & ST16C554_MSR_CTS)
            (*(pChan)->outByte) ((pChan)->data, outChar);
        else
            return (EAGAIN);
        }
    else
        (*(pChan)->outByte) ((pChan)->data, outChar);


    return (OK);
    }
/*rec_data = (*pChan->inByte) (pChan->fcr);
              	  printf("\nfcr = %d", rec_data);
              	  rec_data = (*pChan->inByte) (pChan->lst);
              	  printf("\nlst = %d", rec_data);
              	  rec_data = (*pChan->inByte) (pChan->data);
              	  printf("\nreceive data: %c", rec_data);
              	  printf("\nreceive data: %d\n\n", rec_data);*/