at91 uart driver for vxworks


  1. /* at91UART.c - AT91RM9200 serial driver */  
  2.   
  3. /* Copyright 2003-2004 Coordinate Co., Ltd. */  
  4. /* Copyright 1984-2002 Wind River Systems, Inc. */  
  5.   
  6. /* 
  7. modification history 
  8. -------------------- 
  9. 01a,28jul04,cor  created from original at91Sio.c. 
  10. */  
  11.   
  12. /* 
  13. .SH TODO 
  14.  
  15.  - Replace the documentation for this template driver with documentation 
  16. for the driver being written.   
  17.  
  18.  - Begin with an overview of the complete device.  Indicate if the new driver 
  19. only implements a sub-section of the whole device or not. 
  20.  
  21.  - Describe all of the operating modes of the device, and indicate which 
  22. ones this driver implements. 
  23.  
  24.  - Document the device initialization steps to be used in the BSP to create 
  25. and initialize the device.  Document all the macros that 
  26. can be used to customize the driver to a particular hardware environment. 
  27.  
  28.  - Document anything that will help the user to understand how this device 
  29. works and interacts with this driver. 
  30.  
  31. .SH TEMPLATE OVERVIEW 
  32. This is a template serial driver. It can be used as a starting point 
  33. when writing new drivers for VxWorks version 5.4 or later. 
  34.  
  35. These drivers support new functionality not found in the older style 
  36. serial drivers. First, they provide an interface for setting hardware 
  37. options; e.g., the number of stop bits, data bits, parity, etc. 
  38. Second, they provide an interface for polled communication which 
  39. can be used to provided external mode debugging (i.e., ROM monitor 
  40. style debugging) over a serial line. Currently only asynchronous mode 
  41. drivers are supported. 
  42.  
  43. Throughout this file the word "template" is used in place of a real 
  44. device name, which by convention uses the first letter of the 
  45. manufacturers name followed by the part number. For example, the 
  46. Zilog 8530 serial device would have a data structure called a 
  47. Z8530_CHAN, rather than TEMPLATE_CHAN. 
  48.  
  49. .SH CALLBACKS 
  50. Servicing a "transmitter ready" interrupt involves making a callback to a 
  51. higher level library in order to get a character to transmit. 
  52. By default, this driver installs dummy callback routines which do 
  53. nothing. A higher layer library that wants to use this driver (e.g., ttyDrv) 
  54. will install its own callback routines using the SIO_INSTALL_CALLBACK 
  55. ioctl command. (See below). 
  56.  
  57. The prototype for the transmit data callback SIO_CALLBACK_GET_TX_CHAR is: 
  58. .CS 
  59.     int sioTxCharGet 
  60.     ( 
  61.     void * arg,      /@ callback argument @/ 
  62.     char * pChar         /@ ptr to data location @/ 
  63.     ) 
  64. .CE 
  65. This callback routine should fetch the next character to send and store it 
  66. in the location pointed to by pChar.  It returns OK to indicate that a 
  67. character is ready and should be sent.  It returns ERROR to indicate that 
  68. no character was available and the transmitter can be placed in an idle state. 
  69.  
  70. Likewise, a receiver interrupt handler makes a callback to pass the 
  71. character to the higher layer library.  It will be called by the driver 
  72. for each character received.  This routine should capture the data and pass 
  73. it along to other layers and eventually to the user. 
  74.  
  75. The prototype for the receive data callback SIO_CALLBACK_PUT_RCV_CHAR is: 
  76. .CS 
  77.     void sioRxCharPut 
  78.     ( 
  79.     void * arg,      /@ callback argument @/ 
  80.     char data        /@ data byte @/ 
  81.     ) 
  82. .CE 
  83. A new error handling callback has been added SIO_CALLBACK_ERROR. This driver 
  84. should use this callback to inform the higher layer about error conditions. 
  85. The prototype for this callback is: 
  86. .CS 
  87.     void sioErrorRtn 
  88.     ( 
  89.     void * arg,      /@ callback argument @/ 
  90.     int code,        /@ error code @/ 
  91.     void * pData,        /@ opt dev specific data @/ 
  92.     int dataSize         /@ opt size of data in bytes @/ 
  93.     ) 
  94. .CE 
  95. The available error codes for this callback are: 
  96. .CS 
  97.     SIO_ERROR_FRAMING    /@ (1) Framing error @/ 
  98.     SIO_ERROR_PARITY     /@ (2) Parity error @/ 
  99.     SIO_ERROR_OFLOW  /@ (3) data overflow @/ 
  100.     SIO_ERROR_UFLOW  /@ (4) data underflow @/ 
  101.     SIO_ERROR_CONNECT    /@ (5) connection made @/ 
  102.     SIO_ERROR_DISCONNECT /@ (6) connection lost @/ 
  103.     SIO_ERROR_NO_CLK     /@ (7) clock lost @/ 
  104.     SIO_ERROR_UNKNWN     /@ (8) other errors @/ 
  105. .CE 
  106. For engineering purposes, the driver may return device specific data in 
  107. the form of a data buffer. The argument pData is the location of the buffer 
  108. and dataSize is its size, in bytes.  The data is not guaranteed to be static 
  109. so it should be copied to a static buffer for safekeeping. 
  110.  
  111. .SH MODES 
  112. Ideally the driver should support both polled and interrupt modes, and be 
  113. capable of switching modes dynamically. However this is not required. 
  114. VxWorks will be able to support a tty device on this driver even if 
  115. the driver only supports interrupt mode. 
  116. Polled mode is provided solely for WDB system mode usage.  Users can use 
  117. the polled mode interface directly, but there is no clear reason for doing so. 
  118. Normal access to SIO devices through ttyDrv only uses interrupt mode. 
  119.  
  120. For dynamically switchable drivers, be aware that the driver may be 
  121. asked to switch modes in the middle of its input ISR. A driver's input ISR 
  122. will look something like this: 
  123.  
  124.    inChar = *pDev->dr;          /@ read a char from data register @/ 
  125.    *pDev->cr = GOT_IT;          /@ acknowledge the interrupt @/ 
  126.    pDev->putRcvChar (...);      /@ give the character to the higher layer @/ 
  127.  
  128. If this channel is used as a communication path to an external mode 
  129. debug agent, and if the character received is a special "end of packet" 
  130. character, then the agent's callback will lock interrupts, switch 
  131. the device to polled mode, and use the device in polled mode for awhile. 
  132. Later on the agent will unlock interrupts, switch the device back to 
  133. interrupt mode, and return to the ISR. 
  134. In particular, the callback can cause two mode switches, first to polled mode 
  135. and then back to interrupt mode, before it returns. 
  136. This may require careful ordering of the callback within the interrupt 
  137. handler. For example, you may need to acknowledge the interrupt before 
  138. invoking the callback. 
  139.  
  140. .SH USAGE 
  141. The driver is typically called only by the BSP. The directly callable 
  142. routines in this module are templateSioCreate(), templateSioDestroy(). 
  143.  
  144. .SH BSP 
  145. By convention all the BSP-specific serial initialization is performed in 
  146. a file called sysSerial.c, which is #include'ed by sysLib.c. 
  147.  
  148. This driver can be customized by redefining the macros SYS_SIO_READ8 and 
  149. SYS_SIO_WRITE8.  These two macros are used for all accesses to the 
  150. actual chip.  If not defined, the source code will assume a simple memory 
  151. mapped device using byte read/write access to all registers. 
  152.  
  153. The macros SYS_SIO_INT_CONNECT, SYS_SIO_INT_DISCONNECT, SYS_SIO_INT_ENABLE, 
  154. and SYS_SIO_PROBE can be redefined by the BSP to perform basic low level 
  155. routines with the same calling sequence as intConnect(), intConnect(), 
  156. intEnable(), and vxMemProbe(). 
  157.  
  158. .SH TESTING 
  159. The interrupt driven interface can be tested in the usual way; VxWorks 
  160. prints to the serial console when it comes up, so seeing the usual VxWorks 
  161. output on power-up shows that the driver is basically working. 
  162. The VxWorks portkit test can be used to perform a more strenuous test. 
  163.  
  164. The polled interface should be easy enough to verify - you should be able 
  165. to call the channels SIO_MODE_SET ioctl to put it in polled mode.  Note 
  166. that the usual print tools won't work with a serial channel in polled mode. 
  167. Some agent has to perform a polling loop to handle input/output on a 
  168. character by character basis.  It is not automatic.  The WDB agent 
  169. performs its own polling loop when it switches the WDB serial line into 
  170. polled mode.  
  171.  
  172. The dynamic mode switching can be verified using the tornado tools. 
  173. Reconfigure the agent to use the WDB_COMM_UDLP_SLIP communication path (see 
  174. the Configuration section in the VxWorks run-time Guide for details). 
  175. Start VxWorks, and connect the tgtsvr to the agent using the wdbserial 
  176. backend (see the Tornado Users Guide for details). 
  177. Start the wtxtcl shell as follows: 
  178.     % wtxtcl 
  179. From the tcl prompt, attach to the target server: 
  180.     wtxtcl.ex> wtxToolAttach <tgtsvr name> 
  181. Tell the agent to switch to external mode, and verify the reply is OK (0). 
  182.     wtxtcl.ex>wtxAgentModeSet 2 
  183.     0 
  184. Ask the agent to suspend the system (the request will reach the agent in 
  185. interrupt mode, but the reply will be sent in polled mode): 
  186.     wtxtcl.ex>wtxContextSuspend 0 0 
  187.     0 
  188. At this point the target will be suspended. The console should apprear 
  189. frozen (if the board has a console device), and you will not be able to 
  190. "ping" the target's network interface. 
  191. Resume the target: 
  192.     wtxtcl.ex>wtxContextResume 0 0 
  193.     0 
  194. The target should now be running again, so you should be able to type into 
  195. the console (if the board has a console device) and ping the targets network 
  196. interface from the host. 
  197.  
  198. .SH INCLUDE FILES: 
  199. at91Sio.h sioLib.h 
  200. */  
  201.   
  202. #include "vxWorks.h"  
  203. #include "intLib.h"  
  204. #include "errnoLib.h"  
  205. #include "iosLib.h"     /* For S_iosLib_DEVICE_NOT_FOUND */  
  206. #include "cacheLib.h"  
  207. #include "stdlib.h" /* malloc/free */  
  208. #include "stdio.h"  /* for printf */  
  209. #include "vxLib.h"  /* for vxMemProbe */  
  210. #include "at91.h"  
  211. #include "at91rm9200.h"  
  212. #include "at91If.h"  
  213. #include "at91Sio.h"  
  214. #include "arch\arm\ivarm.h"  
  215.   
  216. #define DEFAULT_BAUD    9600  
  217.   
  218.   
  219. /* channel control register (write) definitions */  
  220.   
  221. #if 0  
  222.   
  223. /* TODO - These are just made up bit defines for a mythical device! */  
  224.   
  225. #define TEMPLATE_RESET_CHIP 0x07    /* reset all */  
  226. #define TEMPLATE_RESET_TX   0x01    /* reset the transmitter */  
  227. #define TEMPLATE_RESET_ERR  0x02    /* reset error condition */  
  228. #define TEMPLATE_RESET_INT  0x04    /* acknoledge the interrupt */  
  229. #define TEMPLATE_INT_ENABLE 0x08    /* enable interrupts */  
  230. #define TEMPLATE_TX_ENABLE  0x10    /* enable interrupts */  
  231. #define TEMPLATE_RX_ENABLE  0x20    /* enable interrupts */  
  232.   
  233. /* channel status register (read) definitions */  
  234.   
  235. #define TEMPLATE_CR_OKAY    0x00    /* no error conditions */  
  236. #define TEMPLATE_CR_TX_READY    0x01    /* txmitter ready for another char */  
  237. #define TEMPLATE_CR_TX_ERROR    0x04    /* txmitter int enable */  
  238. #define TEMPLATE_CR_RX_AVAIL    0x10    /* character has arrived */  
  239. #define TEMPLATE_CR_RX_ERROR    0x40    /* receiver error */  
  240.   
  241. /* channel modem status register definitions */  
  242.   
  243. #define TEMPLATE_MSR_RTS    0x1 /* RTS signal asserted */  
  244. #define TEMPLATE_MSR_DTR    0x2 /* DTR signal asserted */  
  245. #define TEMPLATE_MSR_DSR    0x4 /* DSR signal asserted */  
  246. #define TEMPLATE_MSR_CTS    0x8 /* CTS signal asserted */  
  247. #define TEMPLATE_MSR_CD     0x10    /* CD signal asserted */  
  248.   
  249. /* input and output signals */  
  250.   
  251. #define TEMPLATE_ISIG_MASK  (SIO_MODEM_CTS|SIO_MODEM_DSR|SIO_MODEM_CD)  
  252. #define TEMPLATE_OSIG_MASK  (SIO_MODEM_RTS|SIO_MODEM_DTR)  
  253.   
  254. /* channel modem control register definitions */  
  255.   
  256. #define TEMPLATE_MC_RTS     0x1 /* enable RTS */  
  257. #define TEMPLATE_MC_DTR     0x2 /* enable DTR */  
  258.   
  259. #endif  
  260.   
  261. #define AT91_BAUD_MIN   110  
  262. #define AT91_BAUD_MAX   921600  
  263.   
  264.   
  265. /* Hardware abstraction macros */  
  266.   
  267. #if 0  
  268. /* Macros from BSP */  
  269.   
  270. #define SYS_SIO_READ8(addr, pData) \  
  271.     (*pData = *(UINT8 *)(addr))  
  272. #define SYS_SIO_WRITE8(addr, data) \  
  273.     (*(UINT8 *)addr = data)  
  274. #define SYS_SIO_INT_CONNECT(vec, rtn, arg) \  
  275.     intConnect ((VOIDFUNCPTR *)vec, (VOIDFUNCPTR)rtn, (int)arg)  
  276. #define SYS_SIO_INT_DISCONNECT(vec, rtn, arg) \  
  277.     intConnect ((VOIDFUNCPTR *)vec, NULL, 0)  
  278. #define SYS_SIO_INT_ENABLE(level) \  
  279.     intEnable (level)  
  280. #define SYS_SIO_PROBE(addr, mode, size, pData) \  
  281.     vxMemProbe (addr, mode, size, pData)  
  282. /* #define CACHE_PIPE_FLUSH() */  
  283.   
  284.   
  285. /* Local driver abstractions, following bus/adaptor model */  
  286.   
  287. #define TEMPLATE_SIO_READ8(pChan, reg, result) \  
  288.     SYS_SIO_READ8(((pChan->ioBase) + reg),result)  
  289.   
  290. #define TEMPLATE_SIO_WRITE8(pChan, reg, data) \  
  291.     SYS_SIO_WRITE8(((pChan->ioBase) + reg),data)  
  292.   
  293. #define TEMPLATE_SIO_INT_CONNECT(pChan, vec, rtn, arg) \  
  294.     do { \  
  295.     SYS_SIO_INT_CONNECT((pChan->vecBase) + vec, rtn, arg); \  
  296.     SYS_SIO_INT_ENABLE(pChan->intLevel); \  
  297.     } while (0)  
  298.   
  299. #define TEMPLATE_INT_DISCONNECT(pChan, vec, rtn, arg) \  
  300.     SYS_SIO_INT_DISCONNECT(((pChan)->vecBase + vec), rtn, arg)  
  301.     /* Do NOT disable interrupt level for disconnect */  
  302.   
  303. #define TEMPLATE_PROBE(pChan, offset, dir, size, ptr) \  
  304.     SYS_SIO_PROBE((char *)((pChan)->ioBase + offset), dir, size, ptr)  
  305.   
  306. #define TEMPLATE_PIPE_FLUSH(pChan) \  
  307.     CACHE_PIPE_FLUSH()  
  308.   
  309. #endif   
  310.   
  311. /* forward static declarations */  
  312.   
  313.   
  314. LOCAL int   at91TxStartup (SIO_CHAN * pSioChan);  
  315. LOCAL int   at91CallbackInstall (SIO_CHAN *pSioChan, int callbackType,  
  316.             STATUS (*callback)(void *,...), void *callbackArg);  
  317. LOCAL int   at91PollOutput (SIO_CHAN *pSioChan, char    outChar);  
  318. LOCAL int   at91PollInput (SIO_CHAN *pSioChan, char *thisChar);  
  319. LOCAL int   at91Ioctl (SIO_CHAN *pSioChan, int request, void *arg);  
  320. LOCAL STATUS    at91DummyTxCallback (void *, char *);  
  321. LOCAL void  at91DummyRxCallback (void *, char);  
  322. LOCAL void  at91DummyErrCallback (void *, int, void *, int);  
  323. LOCAL void  at91UARTIntRx (AT91_UART_CHAN * pChan);  
  324. LOCAL void  at91UARTIntTx (AT91_UART_CHAN * pChan);  
  325. LOCAL STATUS    at91Probe (AT91_UART_CHAN * pChan);  
  326. /*  
  327. LOCAL STATUS    at91Verify (AT91_UART_CHAN *pChan); 
  328. LOCAL int   at91MstatGet (AT91_UART_CHAN *pChan); 
  329. LOCAL int   at91MstatSetClr (AT91_UART_CHAN *pChan, UINT bits, BOOL setFlag); 
  330. */  
  331. /* local variables */  
  332.   
  333. LOCAL   SIO_DRV_FUNCS at91UARTDrvFuncs =  
  334.     {  
  335.     at91Ioctl,  
  336.     at91TxStartup,  
  337.     at91CallbackInstall,  
  338.     at91PollInput,  
  339.     at91PollOutput  
  340.     };  
  341.   
  342. /****************************************************************************** 
  343. * 
  344. * at91UARTDevInit - initialise an AT91_SIO channel 
  345. * 
  346. * This routine initialises some SIO_CHAN function pointers and then resets 
  347. * the chip to a quiescent state.  Before this routine is called, the BSP 
  348. * must already have initialised all the device addresses, etc. in the 
  349. * AT91_UART_CHAN structure. 
  350. * 
  351. * RETURNS: N/A 
  352. */  
  353.   
  354. void at91UARTDevInit  
  355.     (  
  356.     AT91_UART_CHAN * pChan  /* ptr to AT91_UART_CHAN describing this channel */  
  357.     )  
  358.     {  
  359.     AT91PS_USART pUsart;    /* point to UART register index by ioBase of pChan */  
  360.     AT91PS_PIO pPIOA, pPIOB;    /* point to  PIO Controller A, B */  
  361.     AT91_UART_PARAS *pParas;  
  362.   
  363.     int oldIntLvl;  
  364.   
  365.     if (pChan != NULL)  
  366.     {  
  367.     pChan->sio.pDrvFuncs = &at91UARTDrvFuncs;  
  368.   
  369.     /* install dummy driver callbacks */  
  370.   
  371.     pChan->getTxChar    = at91DummyTxCallback;  
  372.     pChan->putRcvChar   = at91DummyRxCallback;  
  373.     pChan->errorRtn      = at91DummyErrCallback;  
  374.   
  375.     pChan->intConnect    = FALSE;    /* int's not connected yet */  
  376.   
  377.     /* setting polled mode is one way to make the device quiet */  
  378.     pChan->mode = SIO_MODE_POLL; /* setting mode to poll mode */  
  379.       
  380.     if (at91Probe (pChan) == OK)  
  381.         {  
  382.         oldIntLvl = intLock();  
  383.           
  384.         pParas = pChan->pUart;  
  385.         pChan->ioBase = pParas->ioBase;   /* set parameter of pParas to pChan for easy usage */  
  386.         pUsart = (AT91PS_USART)(pParas->ioBase);  
  387.         pPIOA = (AT91PS_PIO)(AT91RM9200_PIOA_BASE_ADDR);  
  388.         pPIOB = (AT91PS_PIO)(AT91RM9200_PIOB_BASE_ADDR);  
  389.   
  390.         *(volatile unsigned int *)AT91RM9200_PMC_PCER = 1 << pParas->uartId;   /* enable clock */  
  391.         pPIOA->PIO_ASR = pParas->PIOA_ASR;  
  392.         pPIOA->PIO_BSR = pParas->PIOA_BSR;  
  393.         pPIOA->PIO_PDR = pParas->PIOA_ASR | pParas->PIOA_BSR;  
  394.         pPIOB->PIO_ASR = pParas->PIOA_ASR;  
  395.         pPIOB->PIO_BSR = pParas->PIOA_BSR;   
  396.         pPIOB->PIO_PDR = pParas->PIOB_ASR | pParas->PIOB_BSR;  
  397.   
  398.         pUsart->US_IDR = -1; /* disable all USART interrupts */  
  399.         /* reset & disble transmit and receive */  
  400.         pUsart->US_CR = AT91RM9200_US_CR_RSTRX | AT91RM9200_US_CR_RSTTX | \  
  401.                         AT91RM9200_US_CR_RXDIS | AT91RM9200_US_CR_TXDIS;      
  402.         pUsart->US_BRGR = AT91_MASTER_CLOCK / (pParas->baudRate) / 16;    /* 115200 baud with 18.432 Mhz Crystal */  
  403.   
  404.         pUsart->US_RTOR = AT91_USART_RX_TIMEOUT; /* Receiver Time-out Register */  
  405.         pUsart->US_TTGR = 0; /* Transmitter timeguart is disabled */      
  406.         pUsart->US_FIDI = 0; /* in ISO7816 mode, BRG generates no signal */  
  407.   
  408.         /* Disable PDC Channels for DBGU and Initial the State of it */  
  409.         pUsart->US_PTCR = AT91RM9200_PDC_PTCR_TXTDIS | AT91RM9200_PDC_PTCR_RXTDIS;  
  410.   
  411.         pUsart->US_TNPR = 0;  
  412.         pUsart->US_TNCR = 0; /* clear out next transmit counts */  
  413.           
  414.         pUsart->US_RNPR = 0;  
  415.         pUsart->US_RNCR = 0; /* clear out next receive counts */  
  416.           
  417.         pUsart->US_TPR = 0;  
  418.         pUsart->US_TCR = 0;  /* clear out transmit counts */  
  419.   
  420.         pUsart->US_RPR = 0;  
  421.         pUsart->US_RCR = 0;  /* clear out receive counts */  
  422.   
  423.         pUsart->US_MR = pParas->uartOption;   /* default mode */  
  424.               
  425.         intUnlock(oldIntLvl);  
  426.   
  427.         pChan->mode = SIO_MODE_INT;  
  428.   
  429.         /* Enable transmit and received of UART Device */  
  430.         pUsart->US_CR = AT91RM9200_US_CR_RXEN | AT91RM9200_US_CR_TXEN;  
  431.           
  432.         }  
  433.     else  
  434.         {  
  435.         /* Whoops, device is not there! */  
  436.   
  437.         free ((char *)pChan);  
  438.         errnoSet (S_iosLib_DEVICE_NOT_FOUND);  
  439.           
  440.         return;  
  441.         }  
  442.     }  
  443.   
  444.     return;  
  445.     }  
  446.   
  447. /******************************************************************************* 
  448. * 
  449. * at91UARTInt - handle an AT91RM9200 UART interrupt 
  450. * 
  451. * This routine is called to handle AT91RM9200 UART interrupts. 
  452. */  
  453.   
  454. void at91UARTInt  
  455.     (  
  456.     AT91_UART_CHAN *pChan  
  457.     )  
  458.     {  
  459.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */      
  460.     UINT32  status;  
  461.     int errorCode = SIO_ERROR_NONE;  
  462.   
  463.     status = pUsart->US_CSR;  
  464.   
  465.     if (status)  
  466.     {  
  467.         /* we can make below process several times when TXRDY or RXRDY is there */  
  468.           
  469.         if (status & (AT91RM9200_US_SR_RXRDY))  
  470.             at91UARTIntRx (pChan);  
  471.   
  472.         /* Check for error conditions */  
  473.   
  474.         if (status & (AT91RM9200_US_SR_PARE | AT91RM9200_US_SR_FRAME | AT91RM9200_US_SR_OVRE))  
  475.         {  
  476.         /* 
  477.          * Determine precise error condition and perform 
  478.          * recovery actions. 
  479.          */  
  480.             pUsart->US_CR = AT91RM9200_US_CR_RSTSTA;  
  481.               
  482.   
  483.             /* 
  484.              * If needed, you should acknowledge or reset the interrupt source 
  485.              * as soon as possible, usually before passing any error conditions 
  486.              * upstream. 
  487.              */  
  488.             if (status & (AT91RM9200_US_SR_PARE))  
  489.                 {  
  490.                     errorCode = SIO_ERROR_PARITY;  
  491.                 }  
  492.             else if (status & (AT91RM9200_US_SR_FRAME))  
  493.                 {  
  494.                     errorCode = SIO_ERROR_FRAMING;  
  495.                 }  
  496.               
  497.             if (errorCode != SIO_ERROR_NONE)  
  498.             (*pChan->errorRtn) (pChan->errorArg, errorCode, NULL, 0);  
  499.   
  500.             if (status & (AT91RM9200_US_SR_OVRE))  
  501.                 {  
  502.                     errorCode = SIO_ERROR_OFLOW;  
  503.                 (*pChan->errorRtn) (pChan->errorArg, errorCode, NULL, 0);  
  504.                 }  
  505.         }  
  506.   
  507.         if (status & (AT91RM9200_US_SR_TXRDY))  
  508.             at91UARTIntTx (pChan);  
  509.     }  
  510.   
  511.     }  
  512.   
  513. /****************************************************************************** 
  514. * 
  515. * at91UARTIntRx - handle a channel's receive-character interrupt 
  516. * 
  517. * RETURNS: N/A 
  518. */   
  519.   
  520. LOCAL void at91UARTIntRx  
  521.     (  
  522.     AT91_UART_CHAN *    pChan       /* channel generating the interrupt */  
  523.     )  
  524.     {  
  525.     char   inChar;  /* receive data */  
  526.     UINT32 rxStatus = 0; /* receive status */  
  527. /*     
  528.     STATUS status = OK; 
  529.     int errorCode = SIO_ERROR_NONE; 
  530. */  
  531.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */      
  532.   
  533.     /* 
  534.      * 
  535.      * Get status and data from the device. Determine if valid data is ready 
  536.      * or not. 
  537.      * 
  538.      * For PCI devices, do an immediate return if device is not asserting 
  539.      * an interrupt. 
  540.      */  
  541.   
  542.     rxStatus = pUsart->US_CSR;  
  543.       
  544.     while (rxStatus & AT91RM9200_US_SR_RXRDY)  
  545.         {  
  546.         inChar = pUsart->US_RHR;  
  547.         /* RXRDY bit in US_CSR will be clear when RHR is read */  
  548.           
  549.         /* send data character upstream */  
  550.         (*pChan->putRcvChar) (pChan->putRcvArg, inChar);  
  551.   
  552.         if (pChan->mode != SIO_MODE_INT) break;  
  553.   
  554.         rxStatus = pUsart->US_CSR;  
  555.         }  
  556. #if 0   /* will be processed in at91UARTIntErr */  
  557.     if (status == ERROR)  
  558.     {  
  559.     /* send error notification upstream */  
  560.   
  561.     (*pChan->errorRtn) (pChan->errorArg, SIO_ERROR_UNKNWN, NULL, 0);  
  562.     }  
  563. #endif   
  564. #if 0 /* Keyboard emulation code */  
  565.   
  566.     /* 
  567.      * TODO - For a keyboard type device we would map the raw scan code 
  568.      * to ASCII, or other mapping.  Do that here. 
  569.      */  
  570.   
  571.     if (pChan->scanMode == SIO_KYBD_MODE_ASCII)  
  572.         inChar = templateAsciiTbl[(UINT8)inChar];  
  573. #endif  
  574.   
  575.     }  
  576.   
  577. /****************************************************************************** 
  578. * 
  579. * at91UARTIntTx - handle a channels transmitter-ready interrupt 
  580. * 
  581. * RETURNS: N/A 
  582. */   
  583.   
  584. LOCAL void at91UARTIntTx  
  585.     (  
  586.     AT91_UART_CHAN *pChan       /* channel generating the interrupt */  
  587.     )  
  588.     {  
  589.     char    outChar;  
  590.     UINT32 txStatus;    /* status of transmit */  
  591.     /* BOOL txReady = TRUE; */  
  592.     int     errorCode = SIO_ERROR_NONE;  
  593.   
  594.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase);;    /* point to UART register index by ioBase of pChan */          
  595.   
  596.     /* 
  597.      * Check the Tx status 
  598.      * 
  599.      * For PCI devices, do an immediate return if device is not asserting 
  600.      * an interrupt. 
  601.      */  
  602.   
  603. #if 0  
  604.   
  605.     /* Check for error conditions */  
  606.       
  607.     if (crData & TEMPLATE_CR_TX_ERROR)  
  608.     {  
  609.     /* 
  610.      * TODO - Typically you should determine the precise error condition 
  611.      * and perform all recovery operations here. 
  612.      */  
  613.   
  614.     TEMPLATE_SIO_WRITE8 (pChan, TEMPLATE_CSR_ID, TEMPLATE_RESET_TX);  
  615.   
  616.     errorCode = SIO_ERROR_UNKNWN;  
  617.   
  618.     txReady = TRUE; /* set to false if xmitter is not ready now */  
  619.     }  
  620.       
  621. #endif  
  622.     /* 
  623.      * If transmitter is okay and ready to send, lets see if there is a 
  624.      * data character ready to be sent. 
  625.      * 
  626.      * If there's a character to transmit then write it out, else reset (idle) 
  627.      * the transmitter. For chips with output FIFO's it is more efficient 
  628.      * to fill the entire FIFO here. 
  629.      */  
  630.     txStatus = pUsart->US_CSR;  
  631.   
  632.     if (txStatus & AT91RM9200_US_SR_TXRDY)  
  633.     {  
  634.     if ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR)  
  635.         {  
  636.         /* Output data to device.  */  
  637.   
  638.         pUsart->US_THR = outChar;  
  639.         /* need to insert a wait time for transmit finished ? */  
  640.             txStatus = pUsart->US_CSR;  
  641.   
  642.         /* 
  643.          * If a device error occurs at this point, then 
  644.          * isolate the precise error type and try to recover. 
  645.          */  
  646.         }  
  647.     else  
  648.         {  
  649.         /* 
  650.          * There is no more data to send. 
  651.          * 
  652.          * Put XMTR in an idle state. Higher layer 
  653.          * will call TxStartup entry to resume xmit operations. 
  654.          */  
  655.   
  656.         pUsart->US_IDR = AT91RM9200_US_INT_TXRDY;      
  657.            /* 
  658.            pUsart->US_CR = AT91RM9200_US_CR_TXDIS | AT91RM9200_US_CR_RSTTX; */ /* disable transmit */  
  659.              
  660.            /* break; */  
  661.         }  
  662.     }  
  663.   
  664.     /* 
  665.      * If needed, you should acknowledge or reset the interrupt source 
  666.      * as soon as possible, usually before passing any error conditions 
  667.      * upstream. 
  668.      */  
  669.   
  670.     /* US_TXRDY will be cleared when char is sent */  
  671.   
  672.     /* Pass any errorCodes upstream.  */  
  673.   
  674.     if (errorCode != SIO_ERROR_NONE)  
  675.     {  
  676.     (*pChan->errorRtn) (pChan->errorArg, errorCode, NULL, 0);  
  677.     }  
  678.     }  
  679.   
  680. #if 0  
  681.   
  682. /****************************************************************************** 
  683. * 
  684. * at91UARTIntErr - handle a channels error interrupt 
  685. * 
  686. * RETURNS: N/A 
  687. */   
  688.   
  689. LOCAL void at91UARTIntErr  
  690.     (  
  691.     AT91_UART_CHAN *    pChan       /* channel generating the interrupt */  
  692.     )  
  693.     {  
  694.   
  695.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase);;    /* point to UART register index by ioBase of pChan */          
  696.       
  697.     UINT32 errStatus;  
  698.   
  699.     errStatus = pUsart->US_CSR;  
  700.       
  701.     /* 
  702.      * Determine the precise error condition and perform recovery 
  703.      * operations. 
  704.      * 
  705.      * For PCI devices, do an immediate return if device is not asserting 
  706.      * an interrupt. 
  707.      */  
  708.   
  709.     if (errStatus & (AT91C_US_PARE | AT91C_US_FRAME | AT91C_US_OVRE)  
  710.     {  
  711.   
  712.   
  713.     }  
  714. }  
  715. #endif   
  716.   
  717. /****************************************************************************** 
  718. * 
  719. * templateTxStartup - start the interrupt transmitter 
  720. * 
  721. * This routine exits to inform the device to start transmitting data again. 
  722. * The actual data will be obtained by calling the TxCharGet callback routine. 
  723. * 
  724. * This routine is usually just the same as the tx interrupt routine.  This 
  725. * routine runs at task level context and does not have to be interrupt safe. 
  726. * 
  727. * RETURNS: OK on success, ENOSYS if the device is polled-only, or 
  728. * EIO on hardware error. 
  729. */  
  730.   
  731. LOCAL int at91TxStartup  
  732.     (  
  733.     SIO_CHAN * pSioChan                 /* channel to start */  
  734.     )  
  735.     {  
  736.     AT91_UART_CHAN * pChan = (AT91_UART_CHAN *)pSioChan;  
  737.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */  
  738.       
  739.     /* char outChar; */  
  740.   
  741.     /* This routine should only be called while in interrupt mode */  
  742.     /* NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE 
  743.        NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE 
  744.        NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE 
  745.        NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE 
  746.      */  
  747.     /* pChan->mode = SIO_MODE_POLL; */  
  748.   
  749.     if (pChan->mode == SIO_MODE_INT)  
  750.         {  
  751. #if 0  
  752.         if (pChan->options & CLOCAL)  
  753.             {  
  754.             /* No modem control - start immediately */  
  755.             }  
  756.         else  
  757.             {  
  758.         /* 
  759.          * Modem controls are active.  
  760.          * 
  761.          * If CTS is high, we can start immediately so just enable 
  762.          * the TX interrupt. 
  763.          * 
  764.          * If CTS is low, then we cannot send now.  The driver 
  765.          * should be set up to generate a TX interrupt when the CTS 
  766.          * line returns to the active state. 
  767.          */  
  768.             }  
  769.   
  770.         /* 
  771.      * Enable the correct interrupts. A TX interrupt should either 
  772.      * occur immediately, or later when CTS becomes active.  That will start 
  773.      * the flow of data. 
  774.      * 
  775.      * There are two usual methods here.  The first is to just enable 
  776.      * TX interrupts, which should cause an immediate TX interrupt, which 
  777.      * will begin fetching and sending characters. 
  778.      * 
  779.      * The second method is to call the getTxChara callback here, put 
  780.      * the data to the transmitter directly, and then to enable TX 
  781.      * interrupts to fetch and send additional characters. 
  782.      */  
  783. #endif   
  784. #if 0  
  785.     if ((pUsart->US_CSR & AT91C_US_TXRDY) && \  
  786.         ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR))  
  787.         {  
  788.         /* Output data to device.  */  
  789.   
  790.         pUsart->US_THR = outChar;  
  791.   
  792.         /* 
  793.          * If a device error occurs at this point, then 
  794.          * isolate the precise error type and try to recover. 
  795.          */  
  796.         }  
  797. #endif  
  798.   
  799.      /* intEnable(pChan->intLevel); */  
  800.      /* pUsart->US_CR = AT91C_US_TXEN; */  
  801.      pUsart->US_IER = AT91RM9200_US_INT_TXRDY;   /* we need set it again here ? */  
  802.      return OK;  
  803.         }  
  804.     else  
  805. /*      
  806.     while ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR) 
  807.     { 
  808.         while (EAGAIN == at91PollOutput ((SIO_CHAN *)pChan, outChar)); 
  809.     } 
  810. */      
  811.     return ENOSYS;      /* Not valid for polled mode operation */  
  812.   
  813.     return (OK);  
  814.     }  
  815.   
  816.   
  817.   
  818. /****************************************************************************** 
  819. * 
  820. * at91CallbackInstall - install ISR callbacks to get/put chars 
  821. * 
  822. * This driver allows interrupt callbacks for transmitting characters 
  823. * and receiving characters. In general, drivers may support other 
  824. * types of callbacks too. 
  825. * 
  826. * RETURNS: OK on success, or ENOSYS for an unsupported callback type. 
  827. */   
  828.   
  829. LOCAL int at91CallbackInstall  
  830.     (  
  831.     SIO_CHAN *  pSioChan,               /* channel */  
  832.     int     callbackType,           /* type of callback */  
  833.     STATUS  (*callback)(void *,...),  /* callback */  
  834.     void *      callbackArg             /* parameter to callback */  
  835.     )  
  836.     {  
  837.     AT91_UART_CHAN * pChan = (AT91_UART_CHAN *)pSioChan;  
  838.   
  839.     switch (callbackType)  
  840.     {  
  841.     case SIO_CALLBACK_GET_TX_CHAR:  
  842.         pChan->getTxChar = (STATUS (*)(void *, char *))callback;  
  843.         pChan->getTxArg  = callbackArg;  
  844.         return (OK);  
  845.   
  846.     case SIO_CALLBACK_PUT_RCV_CHAR:  
  847.         pChan->putRcvChar    = (void (*)(void *, char))callback;  
  848.         pChan->putRcvArg = callbackArg;  
  849.         return (OK);  
  850.   
  851.     case SIO_CALLBACK_ERROR:  
  852.         pChan->errorRtn  = (void (*)(void *, int, void *, int))callback;  
  853.         pChan->errorArg  = callbackArg;  
  854.         return (OK);  
  855.   
  856.     default:  
  857.         return (ENOSYS);  
  858.     }  
  859.     }  
  860.   
  861. /******************************************************************************* 
  862. * 
  863. * templatePollOutput - output a character in polled mode 
  864. * 
  865. * Polled mode operation takes place without any kernel or other OS 
  866. * services available.  Use extreme care to insure that this code does not 
  867. * call any kernel services.  Polled mode is only for WDB system mode use. 
  868. * Kernel services, semaphores, tasks, etc, are not available during WDB 
  869. * system mode. 
  870. * 
  871. * RETURNS: OK if a character arrived, EIO on device error, EAGAIN 
  872. * if the output buffer if full. ENOSYS if the device is 
  873. * interrupt-only. 
  874. */  
  875.   
  876. LOCAL int at91PollOutput  
  877.     (  
  878.     SIO_CHAN *  pSioChan,  
  879.     char    outChar  
  880.     )  
  881.     {  
  882.     AT91_UART_CHAN * pChan = (AT91_UART_CHAN *)pSioChan;  
  883.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */  
  884.       
  885.     UINT32  status;  
  886.   
  887.     /* is the transmitter ready to accept a character? */  
  888.   
  889.     /* Read TX device status */  
  890.   
  891.     status = pUsart->US_CSR;  
  892.   
  893.     /* determine if transmitter is ready */  
  894.   
  895.     if (0x00 == (status & (AT91RM9200_US_SR_TXRDY)))  
  896.     /* device is busy, try again later */  
  897.         return (EAGAIN);  
  898.       
  899.     /*  transmit the character */  
  900.     pUsart->US_THR = (AT91_REG)outChar;  
  901.   
  902.     return (OK);  
  903.     }  
  904.   
  905. /****************************************************************************** 
  906. * 
  907. * at91PollInput - poll the device for input 
  908. * 
  909. * Polled mode operation takes place without any kernel or other OS 
  910. * services available.  Use extreme care to insure that this code does not 
  911. * call any kernel services.  Polled mode is only for WDB system mode use. 
  912. * Kernel services, semaphores, tasks, etc, are not available during WDB 
  913. * system mode. 
  914. * 
  915. * RETURNS: OK if a character arrived, EIO on device error, EAGAIN 
  916. * if the input buffer if empty, ENOSYS if the device is 
  917. * interrupt-only. 
  918. */  
  919.   
  920. LOCAL int at91PollInput  
  921.     (  
  922.     SIO_CHAN *  pSioChan,  
  923.     char *  thisChar  
  924.     )  
  925.     {  
  926.     AT91_UART_CHAN * pChan = (AT91_UART_CHAN *)pSioChan;  
  927.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */  
  928.       
  929.     UINT32  status;  
  930.   
  931.     /* Read RX device status */  
  932.   
  933.     status = pUsart->US_CSR;  
  934.   
  935.     /* Check if receive data is available */  
  936.   
  937.     if (0x00 == (status & (AT91RM9200_US_SR_RXRDY)))  
  938.     {  
  939.     return EAGAIN;  /* no input available at this time */  
  940.     }  
  941.   
  942.     /* Check for receive error conditions */  
  943.   
  944.     if (0x00 != (status & (AT91RM9200_US_SR_PARE | AT91RM9200_US_SR_FRAME | AT91RM9200_US_SR_OVRE)))  
  945.     {  
  946.     /* Decode and handle the specific error condition */  
  947.   
  948.     pUsart->US_CR = AT91RM9200_US_CR_RSTSTA; /* reset receive of USART to clear error */  
  949.   
  950.     /* Do NOT call the error callback routine, just return EIO */  
  951.   
  952.     return EIO;  
  953.     }  
  954.   
  955.         /* read character, store it, and return OK  */  
  956.   
  957.     *thisChar = (char)(pUsart->US_RHR);  
  958.   
  959.        return (OK);  
  960.     }  
  961.   
  962. /****************************************************************************** 
  963. * 
  964. * at91ModeSet - toggle between interrupt and polled mode 
  965. * 
  966. * RETURNS: OK on success, EIO on unsupported mode. 
  967. */  
  968.   
  969. LOCAL int at91ModeSet  
  970.     (  
  971.     AT91_UART_CHAN * pChan,     /* channel */  
  972.     uint_t      newMode             /* new mode */  
  973.     )  
  974.     {  
  975.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */  
  976.     AT91_UART_PARAS *pParas =  (AT91_UART_PARAS *)(pChan->pUart);  
  977.      
  978.     int oldIntLvl;  
  979.       
  980.     if ((newMode != SIO_MODE_POLL) && (newMode != SIO_MODE_INT))  
  981.     return (EIO);  
  982.   
  983.     oldIntLvl = intLock();  
  984.       
  985.     /*   
  986.      * use this function will made all the action done in  
  987.      * at91IosDevInit be cancelled, so we can't do it now 
  988.     pUsart->US_CR = AT91C_US_RSTRX | AT91C_US_RSTTX; 
  989.     */  
  990.     if (pChan->mode == SIO_MODE_INT)  
  991.     {  
  992.     /* switch device to interrupt mode */  
  993.   
  994.     if (pChan->intConnect == FALSE)  
  995.         {  
  996.         /* interconnect ISR to intvector */;  
  997.         intConnect (INUM_TO_IVEC(pParas->vector), at91UARTInt, (int)pChan);  
  998.         pChan->intConnect = TRUE;  
  999.         }  
  1000.     /* enable interrupt of device */  
  1001.     pUsart->US_IER = AT91RM9200_US_INT_RXRDY | AT91RM9200_US_INT_PARE |AT91RM9200_US_INT_FRAME | AT91RM9200_US_INT_OVRE;  
  1002.     pUsart->US_IDR = AT91RM9200_US_INT_TXRDY;      
  1003.     /* we only enable receive and error interrupt 
  1004.     pUsart->US_IER = AT91RM9200_US_INT_RXRDY | AT91RM9200_US_INT_RXRDY |AT91RM9200_US_INT_PARE | AT91RM9200_US_INT_FRAME |AT91RM9200_US_INT_OVRE; 
  1005.     */  
  1006.     intEnable (pParas->intLevel);  
  1007.     }  
  1008.     else  
  1009.     {  
  1010.     /* switch device to polled mode */  
  1011.   
  1012.     /* disable interrupt of device */  
  1013.     pUsart->US_IDR = -1;     /* disable all interrupt */  
  1014.     intDisable (pParas->intLevel);  
  1015.     }  
  1016.   
  1017.     /* activate  the new mode */  
  1018.   
  1019.     pChan->mode = newMode;  
  1020.   
  1021.     intUnlock(oldIntLvl);  
  1022.   
  1023.     return (OK);  
  1024.     }  
  1025.   
  1026. #if 0  
  1027. /******************************************************************************* 
  1028. * 
  1029. * templateHup - hang up the modem control lines  
  1030. * 
  1031. * Resets the RTS and DTR signals. 
  1032. * 
  1033. * RETURNS: OK always. 
  1034. */  
  1035.   
  1036. LOCAL STATUS at91Hup  
  1037.     (  
  1038.     AT91_UART_CHAN * pChan  /* pointer to channel */  
  1039.     )  
  1040.     {  
  1041.     /* 
  1042.      * TODO - Use global intLock if lockout time will be very short. If not, 
  1043.      * use a device specific lockout that will not damage overall system 
  1044.      * latency. 
  1045.      */  
  1046.   
  1047.     at91MstatSetClr (pChan,(SIO_MODEM_RTS|SIO_MODEM_DTR), FALSE);  
  1048.   
  1049.     return (OK);  
  1050.     }      
  1051.   
  1052.   
  1053. /******************************************************************************* 
  1054. * 
  1055. * at91Open - Set the modem control lines  
  1056. * 
  1057. * Set the modem control lines(RTS, DTR) TRUE if not already set.   
  1058. * 
  1059. * RETURNS: OK 
  1060. */  
  1061.   
  1062. LOCAL STATUS at91Open  
  1063.     (  
  1064.     AT91_UART_CHAN * pChan  /* pointer to channel */  
  1065.     )  
  1066.     {  
  1067.     /* 
  1068.      * TODO - Use global intLock if lockout time will be very short. If not, 
  1069.      * use a device specific lockout that will not damage overall system 
  1070.      * latency. 
  1071.      */  
  1072.   
  1073.     at91MstatSetClr (pChan, (SIO_MODEM_RTS|SIO_MODEM_DTR), TRUE);  
  1074.   
  1075.     return (OK);  
  1076.     }  
  1077. #endif  
  1078.   
  1079.   
  1080. /****************************************************************************** 
  1081. * 
  1082. * at91OptSet - set hardware options 
  1083. * 
  1084. * This routine sets up the hardware according to the specified option 
  1085. * argument.  If the hardware cannot support a particular option value, then 
  1086. * it should ignore that portion of the request. 
  1087. * 
  1088. * RETURNS: OK upon success, or EIO for invalid arguments. 
  1089. */  
  1090.   
  1091. LOCAL int at91OptSet  
  1092.     (  
  1093.     AT91_UART_CHAN * pChan,     /* channel */  
  1094.     uint_t      newOpts             /* new options */  
  1095.     )  
  1096.     {  
  1097.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */  
  1098.     AT91_UART_PARAS *pParas =  (AT91_UART_PARAS *)(pChan->pUart);  
  1099.   
  1100.     int uartHwOptions = pParas->uartOption;  
  1101. /* 
  1102.     BOOL hdweFlowCtrl=TRUE; 
  1103.     BOOL rcvrEnable = TRUE; 
  1104. */  
  1105.     int  oldIntLvl;  
  1106.   
  1107.     if (pChan == NULL || newOpts & 0xffffff00)  
  1108.     return EIO;  
  1109.   
  1110.     /* do nothing if options already set */  
  1111.   
  1112.     if (pParas->uartOption== newOpts)  
  1113.     return OK;  
  1114.   
  1115.     /* ignore requests for unsupported options */  
  1116.   
  1117.     /* decode individual request elements */  
  1118.       
  1119.     uartHwOptions &= ~(AT91RM9200_US_MR_CHRL);   
  1120.   
  1121.     switch (newOpts & CSIZE)  
  1122.     {  
  1123.     case CS5:  
  1124.         uartHwOptions |= AT91RM9200_US_MR_CHRL_5_BITS;  
  1125.         break;  
  1126.     case CS6:  
  1127.         uartHwOptions |= AT91RM9200_US_MR_CHRL_6_BITS;  
  1128.         break;  
  1129.     case CS7:  
  1130.         uartHwOptions |= AT91RM9200_US_MR_CHRL_7_BITS;  
  1131.         break;  
  1132.     default:  
  1133.     case CS8:  
  1134.         uartHwOptions |= AT91RM9200_US_MR_CHRL_8_BITS;  
  1135.         break;  
  1136.     }  
  1137.   
  1138.     uartHwOptions &= ~(AT91RM9200_US_MR_NBSTOP);  
  1139.   
  1140.     if (newOpts & STOPB)  
  1141.             /* 2 bits stop bit */  
  1142.         uartHwOptions |= AT91RM9200_US_MR_NBSTOP_2_BIT;  
  1143.     else  
  1144.             /* 1 bit stop bit */  
  1145.         uartHwOptions |= AT91RM9200_US_MR_NBSTOP_1_BIT;  
  1146.   
  1147.     uartHwOptions &= ~(AT91RM9200_US_MR_PAR);  
  1148.   
  1149.     switch (newOpts & (PARENB|PARODD))  
  1150.     {  
  1151.     case PARENB|PARODD:  
  1152.         /* enable odd parity */  
  1153.         uartHwOptions |= AT91RM9200_US_MR_PAR_ODD;  
  1154.         break;  
  1155.   
  1156.     case PARENB:  
  1157.         /* enable even parity */  
  1158.         uartHwOptions |= AT91RM9200_US_MR_PAR_EVEN;  
  1159.         break;  
  1160.   
  1161.     case PARODD:  
  1162.         /* invalid mode, not normally used. */  
  1163.         uartHwOptions |= AT91RM9200_US_MR_PAR_MULTI_DROP;  
  1164.         break;  
  1165.   
  1166.     default:  
  1167.     case 0:  
  1168.         /* no parity */;   
  1169.         uartHwOptions |= AT91RM9200_US_MR_PAR_NONE;  
  1170.         break;  
  1171.     }  
  1172.   
  1173.     if (newOpts & CLOCAL)  
  1174.     {  
  1175.   
  1176.     /* clocal disables hardware flow control */  
  1177.     uartHwOptions &= ~(AT91RM9200_US_MR_USMODE);  
  1178.     uartHwOptions |= AT91RM9200_US_MR_USMODE_NORMAL;  
  1179.     }  
  1180.     else  
  1181.         {  
  1182.         /* enable hardware flow control */  
  1183.     uartHwOptions &= ~(AT91RM9200_US_MR_USMODE);  
  1184.         uartHwOptions |= AT91RM9200_US_MR_USMODE_HWHSH;  
  1185.         uartHwOptions |= AT91RM9200_US_MR_USMODE_MODEM;  
  1186.         }  
  1187.   
  1188.   
  1189.     if ((newOpts & CREAD) == 0)  
  1190.     pUsart->US_CR = AT91RM9200_US_CR_RXDIS;  
  1191.     else  
  1192.         pUsart->US_CR = AT91RM9200_US_CR_RXEN;  
  1193.   
  1194.     oldIntLvl = intLock ();  
  1195.   
  1196.     /* 
  1197.      * Reset the device according to uartHwOptions 
  1198.      */  
  1199.   
  1200.     pUsart->US_MR = uartHwOptions;  
  1201.       
  1202.     intUnlock (oldIntLvl);  
  1203.   
  1204.     /* 
  1205.      * Be sure that pChan->options reflects the actual 
  1206.      * hardware settings.  If 5 data bits were requested, but unsupported, 
  1207.      * then be sure pChan->options reflects the actual number of data bits 
  1208.      * currently selected. 
  1209.      */  
  1210.   
  1211.     /*  
  1212.      * we store register setting in pParas->uartOption 
  1213.      * and software setting in pChan->options 
  1214.      */  
  1215.     pParas->uartOption = uartHwOptions;  
  1216.     pChan->options = newOpts;  
  1217.   
  1218.     return (OK);  
  1219.     }  
  1220.   
  1221. /******************************************************************************* 
  1222. * 
  1223. * at91Ioctl - special device control 
  1224. * 
  1225. * This routine handles the IOCTL messages from the user. It supports commands  
  1226. * to get/set baud rate, mode(INT,POLL), hardware options(parity, number of  
  1227. * data bits) and modem control(RTS/CTS and DTR/DSR handshakes). 
  1228. * The ioctl commands SIO_HUP and SIO_OPEN are used to implement the HUPCL(hang 
  1229. * up on last close) function. 
  1230. * 
  1231. * As on a UNIX system, requesting a baud rate of zero is translated into 
  1232. * a hangup request.  The DTR and RTS lines are dropped.  This should cause 
  1233. * a connected modem to drop the connection.  The SIO_HUP command will only 
  1234. * hangup if the HUPCL option is active.  The SIO_OPEN function will raise 
  1235. * DTR and RTS lines whenever it is called. Use the BAUD_RATE=0 function 
  1236. * to hangup when HUPCL is not active. 
  1237. * 
  1238. * The CLOCAL option will disable hardware flow control.  When selected, 
  1239. * hardware flow control is not used.  When not selected hardware flow control 
  1240. * is based on the RTS/CTS signals.  CTS is the clear to send input 
  1241. * from the other end.  It must be true for this end to begin sending new 
  1242. * characters.  In most drivers, the RTS signal will be assumed to be connected 
  1243. * to the opposite end's CTS signal and can be used to control output from 
  1244. * the other end.  Raising RTS asserts CTS at the other end and the other end 
  1245. * can send data.  Lowering RTS de-asserts CTS and the other end will stop 
  1246. * sending data. (This is non-EIA defined use of RTS). 
  1247. * 
  1248. * RETURNS: OK on success, ENOSYS on unsupported request, EIO on failed 
  1249. * request. 
  1250. */  
  1251.   
  1252. LOCAL int at91Ioctl  
  1253.     (  
  1254.     SIO_CHAN *  pSioChan,       /* device to control */  
  1255.     int     request,        /* request code */  
  1256.     void *  someArg         /* some argument */  
  1257.     )  
  1258.     {  
  1259.     AT91_UART_CHAN *pChan = (AT91_UART_CHAN *) pSioChan;  
  1260.     AT91PS_USART pUsart = (AT91PS_USART)(pChan->ioBase); /* point to UART register index by ioBase of pChan */  
  1261.     AT91_UART_PARAS *pParas =  (AT91_UART_PARAS *)(pChan->pUart);  
  1262.   
  1263.     int     oldLevel;       /* current interrupt level mask */  
  1264.     int     baudConstant;  
  1265.     int     arg = (int)someArg;  
  1266.   
  1267.     /* TEMPLATE_PIPE_FLUSH(pChan); */  
  1268.     switch (request)  
  1269.     {  
  1270.     case SIO_BAUD_SET:  
  1271.   
  1272.         /* 
  1273.          * like unix, a baud request for 0 is really a request to hangup. 
  1274.          */  
  1275.   
  1276.         if (arg == 0)  
  1277.         return (EIO);  
  1278.           
  1279.         /* return (at91Hup (pChan)); */  
  1280.   
  1281.         /* 
  1282.          * Set the baud rate. Return EIO for an invalid baud rate, or 
  1283.          * OK on success. 
  1284.          */  
  1285.   
  1286.         if (arg < AT91_BAUD_MIN || arg > AT91_BAUD_MAX)  
  1287.             {  
  1288.         return (EIO);  
  1289.             }  
  1290.   
  1291.         /* Calculate the baud rate constant for the new baud rate */  
  1292.   
  1293.         baudConstant = AT91_MASTER_CLOCK / arg / 16;   
  1294.           
  1295.   
  1296.         /* disable interrupts during chip access */  
  1297.   
  1298.         oldLevel = intLock ();  
  1299.         pUsart->US_BRGR = baudConstant;  
  1300.         intUnlock (oldLevel);  
  1301.   
  1302.         pParas->baudRate = arg;  
  1303.   
  1304.         return (OK);  
  1305.   
  1306.     case SIO_BAUD_GET:  
  1307.   
  1308.         *(int *)someArg = pParas->baudRate;  
  1309.         return (OK);  
  1310.   
  1311.     case SIO_MODE_SET:  
  1312.   
  1313.         /* 
  1314.          * Set the mode (e.g., to interrupt or polled). Return OK 
  1315.          * or EIO for an unknown or unsupported mode. 
  1316.          */  
  1317.   
  1318.         return (at91ModeSet (pChan, arg));  
  1319.   
  1320.     case SIO_MODE_GET:  
  1321.   
  1322.         /* Get the current mode and return OK.  */  
  1323.   
  1324.         *(int *)someArg = pChan->mode;  
  1325.         return (OK);  
  1326.   
  1327.     case SIO_AVAIL_MODES_GET:  
  1328.   
  1329.         /* TODO - set the available modes and return OK.  */  
  1330.   
  1331.         *(int *)someArg = SIO_MODE_INT | SIO_MODE_POLL;  
  1332.         return (OK);  
  1333.   
  1334.     case SIO_HW_OPTS_SET:  
  1335.   
  1336.         /* 
  1337.          * Optional command to set the hardware options (as defined 
  1338.          * in sioLib.h). 
  1339.          * Return OK, or ENOSYS if this command is not implemented. 
  1340.          * Note: several hardware options are specified at once. 
  1341.          * This routine should set as many as it can and then return 
  1342.          * OK. The SIO_HW_OPTS_GET is used to find out which options 
  1343.          * were actually set. 
  1344.          */  
  1345.   
  1346.         return (at91OptSet (pChan, arg));  
  1347.   
  1348.     case SIO_HW_OPTS_GET:  
  1349.   
  1350.         /* 
  1351.          * Optional command to get the hardware options (as defined 
  1352.          * in sioLib.h). Return OK or ENOSYS if this command is not 
  1353.          * implemented.  Note: if this command is unimplemented, it 
  1354.          * will be assumed that the driver options are CREAD | CS8 
  1355.          * (e.g., eight data bits, one stop bit, no parity, ints enabled). 
  1356.          */  
  1357.   
  1358.         *(int *)someArg = pChan->options;  
  1359.         return (OK);  
  1360.           
  1361. #if 0  
  1362.         case SIO_HUP:  
  1363.   
  1364.             /* check if hupcl option is enabled */  
  1365.   
  1366.             if (pChan->options & HUPCL)   
  1367.                 return (at91Hup (pChan));  
  1368.             return (OK);  
  1369.   
  1370.         case SIO_OPEN:  
  1371.         return (at91Open (pChan)); /* always open */  
  1372. #endif  
  1373.   
  1374. #if 0 /* TODO - optional modem control line support */  
  1375.   
  1376.     /* 
  1377.      * These new ioctl commands are for monitoring and setting the 
  1378.      * state of the modem control lines under user control. The 
  1379.      * return values from these calls inform the user about which 
  1380.      * control lines are inputs and which are outputs. Basically 
  1381.      * this lets the user know if the device is wired for DTE or 
  1382.      * DCE configuration.  It also informs the user if any signals 
  1383.      * are missing altogether. 
  1384.      */  
  1385.   
  1386.     case SIO_MSTAT_GET:  
  1387.         return templateMstatGet(pChan);  
  1388.   
  1389.     case SIO_MCTRL_BITS_SET:  
  1390.         return templateMstatSetClr (pChan, arg, TRUE);  
  1391.   
  1392.     case SIO_MCTRL_BITS_CLR:  
  1393.         return templateMstatSetClr (pChan, arg, FALSE);  
  1394.   
  1395.     /* 
  1396.      * The ISIG and OSIG masks tell the user which signals are actually 
  1397.      * outputs and which aren't. In our case here, we assume the device 
  1398.      * is DTE mapped with DTR and RTS as outputs. DSR and CTS as inputs. 
  1399.      * This template driver doesn't support RI. 
  1400.      */  
  1401.     case SIO_MCTRL_OSIG_MASK:  
  1402.         *(int *)someArg = TEMPLATE_OSIG_MASK;  
  1403.         break;  
  1404.   
  1405.     case SIO_MCTRL_ISIG_MASK:  
  1406.         *(int *)someArg = TEMPLATE_ISIG_MASK;  
  1407.         break;  
  1408.   
  1409. #endif /* optional Modem control line support */  
  1410.   
  1411. #if 0 /* TODO - optional keyboard scan code support */  
  1412.   
  1413.     /* 
  1414.      * The following new ioctl commands are meant only for keyboard 
  1415.      * input devices to use.  These allow the user to specify and 
  1416.      * examine the type of keyboard character mapping to use.  The 
  1417.      * possible types are NONE (raw scan codes), ASCII (default ascii 
  1418.      * mappings, and UNICODE for standard 16 bit unicode mappings. 
  1419.      * 
  1420.      * Our template driver supports only raw and ascii modes. 
  1421.      */  
  1422.   
  1423.     case SIO_KYBD_MODE_SET:  
  1424.         switch (arg)  
  1425.         {  
  1426.         case SIO_KYBD_MODE_RAW:  
  1427.         case SIO_KYBD_MODE_ASCII:  
  1428.             break;  
  1429.   
  1430.         case SIO_KYBD_MODE_UNICODE:  
  1431.             return ENOSYS; /* template doesn't support unicode */  
  1432.         }  
  1433.         pChan->scanMode = arg;  
  1434.         return OK;  
  1435.   
  1436.     case SIO_KYBD_MODE_GET:  
  1437.         *(int *)someArg = pChan->scanMode;  
  1438.         return OK;  
  1439.   
  1440. #endif /* optional keyboard scan code support */  
  1441.   
  1442.     default:  
  1443.         return ENOSYS;  
  1444.     }  
  1445.     return OK;  
  1446.     }  
  1447.   
  1448. /******************************************************************************* 
  1449. * 
  1450. * dummyTxCallback - dummy Tx callback routine 
  1451. * 
  1452. * RETURNS: ERROR. 
  1453. */  
  1454.   
  1455. LOCAL STATUS at91DummyTxCallback  
  1456.     (  
  1457.     void * callbackArg, /* argument registered with callback */  
  1458.     char * pChara   /* ptr to data location */  
  1459.     )  
  1460.     {  
  1461.     static BOOL doit = TRUE;  
  1462.   
  1463.     /* 
  1464.      * TODO - Until an upstream module connects to this device, there 
  1465.      * is no data available to send.  We should only be concerned 
  1466.      * if this callback is being called repeatedly and often. That 
  1467.      * could indicate an interrupt servicing problem of some kind. 
  1468.      */  
  1469.   
  1470.     if (doit)  
  1471.     {  
  1472.     printf ("Dummy txCallback: 0x%x 0x%x\n",  
  1473.         (int)callbackArg, (int)pChara);  
  1474.     doit = FALSE;  
  1475.     }  
  1476.   
  1477.     return (ERROR);  
  1478.     }  
  1479.   
  1480. /******************************************************************************* 
  1481. * 
  1482. * dummyRxCallback - dummy Rx callback routine 
  1483. * 
  1484. * RETURNS: N/A. 
  1485. * ARGSUSED 
  1486. */  
  1487.   
  1488. LOCAL void at91DummyRxCallback  
  1489.     (  
  1490.     void * callbackArg, /* argument registered with callback */  
  1491.     char data       /* receive data */  
  1492.     )  
  1493.     {  
  1494.     static BOOL doit = TRUE;  
  1495.   
  1496.     /* 
  1497.      * TODO - Device is transferring data, but there is no 
  1498.      * upstream module connected to receive it.  Lets log 
  1499.      * a message about incoming data being lost.  Buts lets 
  1500.      * do this only once we don't want a 'flood' of logged 
  1501.      * messages. 
  1502.      */  
  1503.   
  1504.     if (doit)  
  1505.     {  
  1506.     printf ("Dummy rxCallback: 0x%x 0x%x\n",  
  1507.         (int)callbackArg, (int)data);  
  1508.     doit = FALSE;  
  1509.     }  
  1510.   
  1511.     return;  
  1512.     }  
  1513.   
  1514. /******************************************************************************* 
  1515. * 
  1516. * dummyErrCallback - dummy Error callback routine 
  1517. * 
  1518. * There should be an sioLib module to provide dummyCallbacks for all SIO 
  1519. * drivers to use. 
  1520. * 
  1521. * RETURNS: N/A. 
  1522. * ARGSUSED 
  1523. */  
  1524.   
  1525. LOCAL void at91DummyErrCallback  
  1526.     (  
  1527.     void * callbackArg, /* argument registered with callback */  
  1528.     int errorCode,  /* error code */  
  1529.     void * pData,   /* ptr to device specific data */  
  1530.     int size        /* size of device specific data */  
  1531.     )  
  1532.     {  
  1533.     static BOOL doit = TRUE;  
  1534.   
  1535.     /* TODO -  We could log the reported error (once). */  
  1536.   
  1537.     if (doit)  
  1538.     {  
  1539.     printf ("Dummy errorCallback: 0x%x 0x%x 0x%x %d\n",  
  1540.         (int)callbackArg, errorCode, (int)pData, size);  
  1541.     doit = FALSE;  
  1542.     }  
  1543.   
  1544.     return;  
  1545.     }  
  1546.   
  1547. /******************************************************************************* 
  1548. * 
  1549. * at91Probe - probe for device  
  1550. * 
  1551. * Try to determine if device is present.  Do not reconfigure device if it 
  1552. * is there.  This should be a passive probe that does not interfere with 
  1553. * the device. 
  1554. * 
  1555. * RETURNS: 
  1556. * Returns OK if device adaptor is there, ERROR if not there. 
  1557. */  
  1558.   
  1559. LOCAL STATUS at91Probe  
  1560.     (  
  1561.     AT91_UART_CHAN * pChan /* channel to probe */  
  1562.     )  
  1563.     {  
  1564.     /*  
  1565.      * the UART and DBGU is internal controller of AT91RM9200 CPU,  
  1566.      * so we needn't to probe it 
  1567.      */   
  1568.     return OK;  
  1569.     }  
  1570.   
  1571. #if 0  
  1572. /******************************************************************************* 
  1573. * 
  1574. * at91Verify - verify at91_uart chan structure 
  1575. * 
  1576. * Given a pointer to what should be a AT91_UART_CHAN, verify that it really 
  1577. * is a AT91_UART_CHAN structure. 
  1578. * 
  1579. * This routine should not be called at every level with every routine.  It is 
  1580. * primarily provided for use with the xxxDestroy routine.  Performance will be 
  1581. * a problem if every pointer is checked for validity with every use. 
  1582. * 
  1583. * RETURNS: 
  1584. * Returns OK if pointer is valid, ERROR if not. 
  1585. */  
  1586.   
  1587. LOCAL STATUS at91Verify  
  1588.     (  
  1589.     AT91_UART_CHAN * pChan /* pointer to be verified */  
  1590.     )  
  1591.     {  
  1592.     /* 
  1593.      * Examine the structure. Look for magic cookies or flag bits. 
  1594.      * Anything that would confirm this pointer as being a valid 
  1595.      * AT91_UART_CHAN pointer. 
  1596.      */  
  1597.   
  1598.     if (pChan == NULL)  
  1599.     return ERROR;  
  1600.   
  1601.     return OK;  
  1602.     }  
  1603.   
  1604. #endif  
  1605.   
  1606. #if 0 /* Optional modem control line support */  
  1607.   
  1608. /******************************************************************************* 
  1609. * 
  1610. * at91MstatGet - read device modem control line status 
  1611. * 
  1612. * Read the device modem control lines and map them to the standard 
  1613. * modem signal bits. 
  1614. * 
  1615. * RETURNS: 
  1616. * Returns the modem control line status bits. 
  1617. */  
  1618.   
  1619. LOCAL int at91MstatGet  
  1620.     (  
  1621.     AT91_UART_CHAN *pChan  
  1622.     )  
  1623.     {  
  1624.     AT91_UART_CHAN * pChan = (AT91_UART_CHAN *)pSioChan;  
  1625.     UINT32  status;  
  1626.     int result = 0;  
  1627.   
  1628.     AT91PS_USART pUsart;    /* point to UART register index by ioBase of pChan */  
  1629.   
  1630.     pUsart = (AT91PS_USART)(pChan->ioBase);  
  1631.   
  1632.     /* Read RX device status */  
  1633.   
  1634.     status = pUsart->US_CSR;  
  1635.     /* Now map device status bits, to standard status bits */  
  1636.   
  1637.     if (rawStatus & TEMPLATE_MSR_CD)  
  1638.     result |= SIO_MODEM_CD;  
  1639.   
  1640.     if (rawStatus & TEMPLATE_MSR_DTR)  
  1641.     result |= SIO_MODEM_DTR;  
  1642.   
  1643.     if (rawStatus & TEMPLATE_MSR_DSR)  
  1644.     result |= SIO_MODEM_DSR;  
  1645.   
  1646.     if (rawStatus & TEMPLATE_MSR_RTS)  
  1647.     result |= SIO_MODEM_RTS;  
  1648.   
  1649.     if (rawStatus & TEMPLATE_MSR_CTS)  
  1650.     result |= SIO_MODEM_CTS;  
  1651.   
  1652.     return result;  
  1653.     }  
  1654.   
  1655. /******************************************************************************* 
  1656. * 
  1657. * templateMstatSetClear - set/clear modem control lines 
  1658. * 
  1659. * This routine allows the user to set or clear individual modem control 
  1660. * lines.  Of course, only the output lines can actually be changed. 
  1661. * 
  1662. * RETURNS: 
  1663. * OK, or EIO upon detecting a hardware fault. 
  1664. */  
  1665.   
  1666. LOCAL int templateMstatSetClr  
  1667.     (  
  1668.     TEMPLATE_CHAN *pChan,  
  1669.     UINT bits,      /* bits to change */  
  1670.     BOOL setFlag    /* TRUE = set, FALSE = clear */  
  1671.     )  
  1672.     {  
  1673.     UINT8 rawStatus;  
  1674.     UINT8 rawMask = 0;  
  1675.   
  1676.     /* Read current modem status */  
  1677.     TEMPLATE_SIO_READ8 (pChan, TEMPLATE_MSR_ID, &rawStatus);  
  1678.   
  1679.     /* ignore input only bits */  
  1680.     bits &= TEMPLATE_OSIG_MASK;  
  1681.   
  1682.     /* Now map standard bits to device specific bits */  
  1683.   
  1684.     if (bits & SIO_MODEM_DTR)  
  1685.     rawMask |= TEMPLATE_MSR_DTR;  
  1686.   
  1687.     if (bits & SIO_MODEM_RTS)  
  1688.     rawMask |= TEMPLATE_MSR_RTS;  
  1689.   
  1690.     /* Update device with new output signals */  
  1691.   
  1692.     if (setFlag)  
  1693.     rawStatus |= rawMask; /* set new bits */  
  1694.     else  
  1695.     rawStatus &= ~rawMask; /* clear bits */  
  1696.   
  1697.     TEMPLATE_SIO_WRITE8 (pChan, TEMPLATE_MSR_ID, rawStatus);  
  1698.   
  1699.     return OK;  
  1700.     }  
  1701. #endif /* optional modem control line support */  
 

posted on 2015-09-17 10:26  嵌入式操作系统  阅读(657)  评论(0)  编辑  收藏  举报

导航