pChan->putRcvArg     = callbackArg;        return (OK);    default:        return (ENOSYS);    }    }/********************************************************************************* at91cPollOutput - output a character in polled mode** RETURNS: OK if a character arrived, EIO on device error, EAGAIN* if the output buffer if full. ENOSYS if the device is* interrupt-only.*/LOCAL int at91cPollOutput    (    SIO_CHAN *pSioChan,    char      outChar    )    {    AT91C_CHAN * pChan = (AT91C_CHAN *)pSioChan;    UINT32    status;    /* is the transmitter ready to accept a character? */    AT91C_SIO_REG_READ (pChan, AT91C_US_CSR, status);    if ((status & AT91C_US_TXREADY) == 0x00)        return (EAGAIN);    /* write out the character */    AT91C_SIO_REG_WRITE(pChan, AT91C_US_THR, outChar);    return (OK);    }/******************************************************************************** at91cPollInput - poll the device for input** RETURNS: OK if a character arrived, EIO on device error, EAGAIN* if the input buffer if empty, ENOSYS if the device is* interrupt-only.*/LOCAL int at91cPollInput    (    SIO_CHAN *    pSioChan,    char *        thisChar    )    {    AT91C_CHAN * pChan = (AT91C_CHAN *)pSioChan;    UINT32    status;    AT91C_SIO_REG_READ (pChan,AT91C_US_CSR, status);    if ((status & AT91C_US_RXREADY) == 0x00)        return (EAGAIN);    /* no input available at this time */    /* got a character */    AT91C_SIO_REG_READ(pChan, AT91C_US_RHR, *thisChar);    return (OK);    }/******************************************************************************** at91cModeSet - toggle between interrupt and polled mode** RETURNS: OK on success, EIO on unsupported mode.*/LOCAL int at91cModeSet    (    AT91C_CHAN * pChan,        /* channel */    uint_t          newMode       /* new mode */    )    {/*    UINT32    temp;*/    if ((newMode != SIO_MODE_POLL) && (newMode != SIO_MODE_INT))        return (EIO);    /* Don't enter interrupt mode unless it is allowed. */    if ((newMode == SIO_MODE_INT) && (!at91cIntrMode))    return (EIO);    /* set the new mode */    pChan->mode = newMode;    if (pChan->mode == SIO_MODE_INT)        {                AT91C_SIO_REG_WRITE(pChan, AT91C_US_CR,AT91C_US_RSTRX | AT91C_US_RSTTX);    /*Reset RX & TX*/        AT91C_SIO_REG_WRITE(pChan, AT91C_US_CR, AT91C_US_RXEN |AT91C_US_TXEN);		/*Enable Rx & Tx*/	 AT91C_SIO_REG_WRITE(pChan, AT91C_US_IER, AT91C_US_RXRDY |AT91C_US_TXRDY);	/*Enable Rx & Tx interrupt*/        intEnable(pChan->intLevel);        }    else        { 	 AT91C_SIO_REG_WRITE(pChan, AT91C_US_CR,AT91C_US_RSTRX | AT91C_US_RSTTX);    /*Reset RX & TX*/        AT91C_SIO_REG_WRITE(pChan, AT91C_US_CR, AT91C_US_RXEN |AT91C_US_TXEN);		/*Enable Rx & Tx*/        intDisable (pChan->intLevel);        }	    return (OK);    }/********************************************************************************* at91cHup - hang up the modem control lines ** Resets the RTS and DTR signals.** RETURNS: OK*/LOCAL STATUS at91cHup    (    AT91C_CHAN * pChan     /* pointer to channel */    )    {    FAST int     oldlevel;    /* current interrupt level mask */    oldlevel = intLock ();    /* set RTS and DTR low */    /*AT91C_SIO_REG_WRITE(pChan, AT91C_US_CR, AT91C_US_RTSDIS | AT91C_US_DTRDIS);            */    intUnlock (oldlevel);    return (OK);    }    /********************************************************************************* at91cOpen - Set the modem control lines ** Set the modem control lines(RTS, DTR) TRUE if not already set.  ** RETURNS: OK*/LOCAL STATUS at91cOpen    (    AT91C_CHAN * pChan     /* pointer to channel */    )    {    FAST int     oldlevel;    /* current interrupt level mask */    oldlevel = intLock ();    /* set RTS and DTR active *//*    AT91C_SIO_REG_WRITE(pChan, AT91C_US_CR, AT91C_US_RTSEN | AT91C_US_DTREN);    */    intUnlock (oldlevel);    return (OK);    }/******************************************************************************** at91cOptSet - set hardware options** This routine sets up the hardware according to the specified option* argument.  If the hardware cannot support a particular option value, then* it should ignore that portion of the request.** RETURNS: OK upon success, or EIO for invalid arguments.*/LOCAL int at91cOptSet    (    AT91C_CHAN * pChan,        /* channel */    uint_t    newOpts              /* new options */    )    {                UINT32 dataBits = AT91C_US_CHRL_8_BITS;    UINT32 stopBits = AT91C_US_NBSTOP_1_BIT;    BOOL hdweFlowCtrl=TRUE;    BOOL rcvrEnable = TRUE;    int  lvl;    UINT32 temp=AT91C_US_PAR_NONE;    UINT32 result;        if (pChan == NULL || newOpts & 0xffffff00)    return EIO;    /* do nothing if options already set */    if (pChan->options == newOpts)    return OK;    /* ignore requests for unsupported options */    /* decode individual request elements */    switch (newOpts & CSIZE)    {    case CS5:        dataBits = AT91C_US_CHRL_5_BITS; break;    case CS6:        dataBits = AT91C_US_CHRL_6_BITS; break;    case CS7:        dataBits = AT91C_US_CHRL_7_BITS; break;    default:    case CS8:        dataBits = AT91C_US_CHRL_8_BITS; break;    }    if (newOpts & STOPB)        stopBits = AT91C_US_NBSTOP_2_BIT;    else        stopBits = AT91C_US_NBSTOP_1_BIT;    switch (newOpts & (PARENB|PARODD))    {    case PARENB|PARODD:        /* enable odd parity */            temp=AT91C_US_PAR_ODD;        break;    case PARENB:        /* enable even parity */        temp=AT91C_US_PAR_EVEN;         break;    case PARODD:        /* invalid mode, not normally used. */        break;    default:    case 0:        temp=AT91C_US_PAR_NONE ;/* no parity */        break;    }    if (newOpts & CLOCAL)    {        /* clocal disables hardware flow control */        hdweFlowCtrl = FALSE;    }    if ((newOpts & CREAD) == 0)        rcvrEnable = FALSE;    lvl = intLock ();    /*     * Reset the device according to dataBits, stopBits, hdweFlowCtrl,     * rcvrEnable, and parity selections.     */    /*    AT91C_SIO_REG_READ(pChan, AT91C_US_MR, result);        AT91C_SIO_REG_WRITE(pChan,AT91C_US_MR,(result|dataBits|temp|stopBits));*/    AT91C_SIO_REG_WRITE(pChan,AT91C_US_CR,AT91C_US_RSTRX | AT91C_US_RSTTX);/*RESET*/    AT91C_SIO_REG_WRITE(pChan,AT91C_US_CR,AT91C_US_RXEN | AT91C_US_TXEN);	/*TX&RX ENABLE*/    AT91C_SIO_REG_WRITE(pChan,AT91C_US_MR,(dataBits|temp|stopBits));       intUnlock (lvl);    pChan->options = newOpts;    return (OK);    }/********************************************************************************* at91cIoctl - special device control** This routine handles the IOCTL messages from the user. It supports commands * to get/set baud rate, mode(INT,POLL), hardware options(parity, number of * data bits) and modem control(RTS/CTS and DTR/DSR handshakes).* The ioctl commands SIO_HUP and SIO_OPEN are used to implement the HUPCL(hang* up on last close) function.** As on a UNIX system, requesting a baud rate of zero is translated into* a hangup request.  The DTR and RTS lines are dropped.  This should cause* a connected modem to drop the connection.  The SIO_HUP command will only* hangup if the HUPCL option is active.  The SIO_OPEN function will raise* DTR and RTS lines whenever it is called. Use the BAUD_RATE=0 function* to hangup when HUPCL is not active.** The CLOCAL option will disable hardware flow control.  When selected,* hardware flow control is not used.  When not selected hardware flow control* is based on the RTS/CTS signals.  CTS is the clear to send input* from the other end.  It must be true for this end to begin sending new* characters.  In most drivers, the RTS signal will be assumed to be connected* to the opposite end's CTS signal and can be used to control output from* the other end.  Raising RTS asserts CTS at the other end and the other end* can send data.  Lowering RTS de-asserts CTS and the other end will stop* sending data. (This is non-EIA defined use of RTS).** RETURNS: OK on success, ENOSYS on unsupported request, EIO on failed* request.*/LOCAL int at91cIoctl    (    SIO_CHAN *    pSioChan,        /* device to control */    int        request,        /* request code */    void *    someArg            /* some argument */    )    {    AT91C_CHAN *pChan = (AT91C_CHAN *) pSioChan;    int     oldlevel;        /* current interrupt level mask */    int     arg = (int)someArg;        switch (request)    {    case SIO_BAUD_SET:        /*         * like unix, a baud request for 0 is really a request to         * hangup.         */        if (arg == 0)        return at91cHup (pChan);        /*         * Set the baud rate. Return EIO for an invalid baud rate, or         * OK on success.         */        if (arg < AT91C_BAUD_MIN || arg > AT91C_BAUD_MAX)            {        return (EIO);            }	            /* Calculate the baud rate constant for the new baud rate */            switch(arg)                {	           case 1200:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR, AT91C_CD_1200);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 2400:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR, AT91C_CD_2400);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 4800:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR, AT91C_CD_4800);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 9600:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,AT91C_CD_9600);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 19200:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,AT91C_CD_19200);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 38400:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,AT91C_CD_38400);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 57600:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,AT91C_CD_57600);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 115200:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,AT91C_CD_115200);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);                case 230400:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,AT91C_CD_230400);                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);#if 0                case 460800:                    /* disable interrupts during chip access */                    oldlevel = intLock ();                    AT91C_SIO_REG_WRITE(pChan,AT91C_US_BRGR,   );                    intUnlock (oldlevel);                    pChan->baudRate=arg;                    return (OK);   #endif                       default:                    return(EIO);                }            break;    case SIO_BAUD_GET:            /* Get the baud rate and return OK */            *(int *)arg = pChan->baudRate;            break;    case SIO_MODE_SET:        /*         * Set the mode (e.g., to interrupt or polled). Return OK         * or EIO for an unknown or unsupported mode.         */        return (at91cModeSet (pChan, arg));    case SIO_MODE_GET:                    /* Get the current mode and return OK.  */        *(int *)arg = pChan->mode;        return (OK);    case SIO_AVAIL_MODES_GET:        /* Get the available modes and return OK.  */        *(int *)arg = SIO_MODE_INT | SIO_MODE_POLL;         return (OK);    case SIO_HW_OPTS_SET:        /*         * Optional command to set the hardware options (as defined         * in sioLib.h).         * Return OK, or ENOSYS if this command is not implemented.         * Note: several hardware options are specified at once.         * This routine should set as many as it can and then return         * OK. The SIO_HW_OPTS_GET is used to find out which options         * were actually set.         */        return (at91cOptSet (pChan, arg));    case SIO_HW_OPTS_GET:        /*         * Optional command to get the hardware options (as defined         * in sioLib.h). Return OK or ENOSYS if this command is not         * implemented.  Note: if this command is unimplemented, it         * will be assumed that the driver options are CREAD | CS8         * (e.g., eight data bits, one stop bit, no parity, ints enabled).         */        *(int *)arg = pChan->options;        return (OK);    case SIO_HUP:            /* check if hupcl option is enabled */            if (pChan->options & HUPCL)                 return (at91cHup (pChan));            return (OK);    case SIO_OPEN:            return (at91cOpen (pChan)); /* always open */    default:        return (ENOSYS);    }    return (ENOSYS);    }/********************************************************************************* dummyCallback - dummy callback routine** RETURNS: ERROR.*/LOCAL STATUS dummyCallback (void)    {    return (ERROR);    }#if 0void myDelay(){	int i;		*(volatile UINT32 *)0xfffff800 = 0x35;	*(volatile UINT32 *)0xfffff810 = 0x35;		while(1)	{	*(volatile UINT32 *)0xfffff834 = 0x35;/*lit*/		for(i=0;i<1000000;i++);		*(volatile UINT32 *)0xfffff830 = 0x35;		for(i=0;i<1000000;i++);		}}#endif