开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
sc2440_usb_hw.c
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：46k
源码类别：

Windows CE

开发平台：

Windows_Unix

sc2440_usb_hw.c：源码内容
  2. /**
  3. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  4. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  5. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  6. PARTICULAR PURPOSE.
  7. Copyright (c) 2001. Samsung Electronics, co. ltd  All rights reserved.
  9. Module Name:  
  11. Abstract:
  13.     S3C2440 USB function(ACTIVE SYNC) device driver (Chip Layer)
  15. rev:
  16. 2003.3.18 : EP3 is replaced by EP4 for DMA operation because DMA2(EP3) is used by audio. (purnnamu)
  17. 2003.3.17 : Every USBD interrupt is followed by the dummy interrupt 
  18.   because USBD sub-pending interrupt is cleared after clearing INTPND register.
  19.   So,USBD sub-pending bit is cleared before clearing INTPND register. (purnnamu)
  20.     2002.5.7 : Add to s3c2410_code (Seung-han, Lim)
  21.     2002.1.22 : First release/no error recovery (kwangyoon LEE, kwangyoon@samsung.com)
  22. Notes: 
  23. */
  25. #include <windows.h>
  26. #include <types.h>
  27. #include <ceddk.h>
  28. #include <memory.h>
  29. #include <serhw.h>
  30. #include <nkintr.h>
  33. #include "S2440.h"
  34. #include <SC2440_usb_hw.h>
  35. #include <SC2440_usb_ser.h>
  36. #undef ZONE_INIT
  37. #include <serdbg.h>
  38. #include <drv_glob.h> //:-)
  39. #include <2440usb.h>  //:-)
  41. #define USBDMSG  DEBUGMSG  //RETAILMSG
  43. PDRIVER_GLOBALS v_pDriverGlobals=NULL; //:-)
  44. volatile USBD_GLOBALS *usbdShMem=NULL;  //:-)
  45. volatile DMAreg *v_pDMAregs=NULL;  //:-)
  46. volatile INTreg *v_pINTregs=NULL;  //:-)
  47. ULONG realPhysicalAddr_UsbdRxBuf=0;
  49. ULONG totalRxCnt=0; //debug
  50. /*
  51. #if (USBD_GLOBALS_BUF_SIZE!=0x4000)
  52. STOP_COMPILE GEN_ERROR
  53. //drv_glob.h should be changed correctly
  54. #endif
  55. */
  57. // This driver defines a simple BULK FIFO device. It supports only one
  58. // interface with one alternate setting, as shown below.  
  59. //
  60. //  Endpoint    Setting 0
  61. //------------------------
  62. //  EP0         Control
  63. //  EP1 In      Bulk  
  64. //  EP3 Out     Bulk   
  66. // Steal the useless IR zone from MDD and use it as EP0 & USB specific stuff
  67.  
  68. #define ZONE_USB ZONE_IR
  70. // Define the configuration descriptor length
  71.  
  72. #define CFGLEN  32   
  73. #define iCONF   18
  74. #define TLEN    (CFGLEN + 18)
  76. // Define the configuration descriptor itself
  78. const BYTE uStd[TLEN]=  {
  79. 0x12, //  0 desc size                      
  80. DEVICE, //  1 desc type (DEVICE)             
  81. 0x00, //  2 USB release                    
  82. 0x01, //  3 => 1.00                        
  83. 0xff, //  4 class                          
  84. 0xff, //  5 subclass                       
  85. 0xff, //  6 protocol                       
  86. EP0_MAXP_SIZE, //  7 max pack size                  
  87. 0x47, //  8 vendor ID LSB (Samsung Semi)   
  88. 0x05, //  9 vendor ID MSB ( 0x1419 )       
  89. 0x20, // 10 product ID LSB                 
  90. 0x27, // 11 product ID MSB                 
  91. 0x00, // 12 device release LSB             
  92. 0x00, // 13 device release MSB             
  93. 0x00, // 14 manufacturer string desc index 
  94. 0x00, // 15 product string desc index      
  95. 0x00, // 16 serial num string desc index   
  96. 0x01, // 17 num of possible configurations 
  98. // Configuration Descriptor 
  99. 0x09, //  desc size                            
  100. CONFIGURATION, //  desc type (CONFIGURATION)            
  101. CFGLEN%256, //  total length of data returned LSB    
  102. CFGLEN/256, //  total length of data returned MSB    
  103. 0x01, //  num of interfaces                    
  104. 0x01, //  value to select config (1 for now)   
  105. 0x00, //  index of string desc ( 0 for now)    
  106. 0x80, //  bus powered                          
  107. 25, //  max power, 50mA for now    
  109. // Interface Decriptor 
  110. 0x09, //  desc size                            
  111. INTERFACE, //  desc type (INTERFACE)                
  112. 0x00, //  interface index.                     
  113. 0x00, //  value for alternate setting          
  114. 0x02, //  bNumEndpoints (number endpoints used, excluding EP0)
  115. 0xff,
  116. 0xff,
  117. 0xff,
  118. 0x00, //  string index,      
  120. // Endpoint descriptor (EP 1 Bulk IN) 
  121. 0x07, //  desc size                            
  122. ENDPOINT, //  desc type (ENDPOINT)                 
  123. 0x81, //  endpoint address: endpoint 1, IN    
  124. 0x02, //  endpoint attributes: Bulk       
  125. EP1_IN_MAXP_SIZE, //  max packet size LSB                  
  126. 0x00, //  max packet size MSB                  
  127. 0x00, //  polling interval (4ms/bit=time,500ms)  
  129. #if 0
  130. // Endpoint descriptor (EP 2 Interrupt IN) 
  131. 0x07, //  desc size                            
  132. ENDPOINT, //  desc type (ENDPOINT)                 
  133. 0x82, //  endpoint address: endpoint 2, IN     
  134. 0x03, //  endpoint attributes: Interrupt       
  135. EP2_IN_MAXP_SIZE, //  max packet size LSB                  
  136. 0x00, //  max packet size MSB                  
  137. 0xFA, //  polling interval (4ms/bit=time,100ms)  
  138. #endif
  140. // Endpoint descriptor (EP 4 Bulk OUT) 
  141. 0x07, //  desc size                            
  142. ENDPOINT, //  desc type (ENDPOINT)                 
  143. 0x04, //  endpoint address: endpoint 4, OUT    
  144. 0x02, //  endpoint attributes: Bulk            
  145. EP4_OUT_MAXP_SIZE, //  max packet size LSB                  
  146. 0x00, //  max packet size MSB                  
  147. 0x00 //  polling interval (4ms/bit=time,500ms)  
  149. #if 0
  150. // Endpoint descriptor (EP 4 Interrupt OUT) 
  151. 0x07, //  desc size                            
  152. ENDPOINT, //  desc type (ENDPOINT)                 
  153. 0x04, //  endpoint address: endpoint 4, OUT    
  154. 0x03, //  endpoint attributes: Interrupt            
  155. EP4_OUT_MAXP_SIZE, //  max packet size LSB                  
  156. 0x00, //  max packet size MSB                  
  157. 0x00 //  polling interval (4ms/bit=time,500ms)   // $$$$
  158. #endif
  159. };
  161. // Register writes need to be verified. This macro loops the write until
  162. // the effects are visible and records the number of retries.
  164. #define UDC_REG_WRITE(_struct,_ptr,_field,_val) IOW_REG_FIELD(_struct,_ptr,_field,_val)
  166. #define UDC_REG_BITSET(_struct,_ptr,_field,_val) { _struct xx;
  167.         *(unsigned int *)&xx = 0;
  168.       xx._field = _val;
  169.       IOW_REG_SET(_struct,_ptr,*(unsigned int*)&xx); }
  171. #define UDC_REG_WRITEX(_setptr,_setval) (_setptr) = _setval;
  173. // Variables for EP0 resend control. Keep track of last packet sent.
  175. static char *sendPacket;
  176. static int  sendPacketLength;
  177. static int  sendTotalLength;
  178. static char *savSendPacket;
  179. static int  savSendPacketLength;
  181. // EP1/EP3 packet size. For polling this can not be greater than 16
  183. static unsigned int maxPacketSize = EP1Len;  
  185. // Read the command from the endpoint 0 FIFO 
  187. void HW_USBClocks(PSER_INFO pHWHead);
  190. static
  191. int getCommand(PSER_INFO pHWHead, void *argP)
  192. {
  193. unsigned char *bufP = (unsigned char*)argP;
  194. int length     = pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low | pHWHead->pUSBCtrlAddr->OFCR2.out_cnt_high<<8;
  195. int i;
  197. memset(bufP, 0x55, 8);
  199. // All setup commands are 8 bytes in length
  200. if (length != 8) 
  201. {
  202. DEBUGMSG(1, (TEXT("UDC bad command length %dn"), length));
  203. return 1;
  204. }
  206. DEBUGMSG(1, (TEXT("[GETCOMMAND : ")));
  208. for (i=0; i < length; i++) 
  209. {
  210. bufP[i] = (BYTE)pHWHead->pUSBCtrlAddr->EP0F.fifo_data;
  211. DEBUGMSG(1, (TEXT("%2x "), bufP[i]));
  212. }
  214. DEBUGMSG(1, (TEXT("]rn")));
  216. return 0;
  217. }
  219. /*************************************************************************
  220. Command response with data packets
  221. *************************************************************************/
  222. static
  223. void sendData(PSER_INFO pHWHead, void *argP, int length, int totalLen)
  224. {
  226. unsigned char *bufP = (unsigned char*)argP;
  227. struct EP0ICSR1Bits EP0ICSR1;
  228. int i;
  230. // Endpoint0 mode
  231. pHWHead->pUSBCtrlAddr->INDEX.index = 0x0;
  233. DEBUGMSG(1, (TEXT("[UDC WILL SEND] %d bytesrn"), length));
  235. // Send the data back. The FIFO should be turned around for
  236. // us already. Just blast away ...
  237.   for (i=0; (i < length) && (i < EP0Len); i++) 
  238. {
  239. IOW_REG_FIELD(struct EP0FBits, 
  240. &pHWHead->pUSBCtrlAddr->EP0F, fifo_data, bufP[i]);
  241. }
  243. // Form the register update. Always set IN_PKT_RDY.
  244. EP0ICSR1 = pHWHead->pUSBCtrlAddr->EP0ICSR1;
  245. EP0ICSR1.ipr_ = 1;
  247. // We can complete on a packet which is full. We need to wait till
  248. // next time and generate a zero length packet, so only complete
  249. // if we're at the end and it is not the max packet size.
  250. if ((i == length) && (i != EP0Len)) 
  251. {
  252. savSendPacket       = sendPacket;
  253. savSendPacketLength = sendPacketLength;
  254. sendPacket          = NULL;
  255. sendPacketLength    = length - i;
  256. sendTotalLength     = totalLen - i;
  257. EP0ICSR1.de_ff = 1;
  258. }
  259. // Need to send another packet.
  260. else {
  261. sendPacket          = (char*)&bufP[i];
  262. sendPacketLength    = length - i;
  263. sendTotalLength     = totalLen - i;
  264. savSendPacket       = sendPacket;
  265. savSendPacketLength = sendPacketLength;
  267. DEBUGMSG(1, (TEXT("UDC WILL SEND %d more bytes laterrn"), 
  268. sendPacketLength));
  269. }
  271. /* Update the register
  272. */
  273. UDC_REG_WRITEX(*(volatile unsigned *)&pHWHead->pUSBCtrlAddr->EP0ICSR1, 
  274.   *(unsigned *)&EP0ICSR1);
  275. }
  277. /*************************************************************************
  278. Send command done
  279. *************************************************************************/
  280. static
  281. void sendCommandDone(PSER_INFO pHWHead)
  282. {
  283. BYTE index;
  285. // Endpoint0 mode
  286.     index = pHWHead->pUSBCtrlAddr->INDEX.index;
  287.     pHWHead->pUSBCtrlAddr->INDEX.index = 0x0;
  289.     // Set SERVICE_OUT_PKY_RDY bit
  290.     pHWHead->pUSBCtrlAddr->EP0ICSR1.sopr_cdt = 0x1;
  291.     
  292.     pHWHead->pUSBCtrlAddr->INDEX.index = index;
  293. }
  295. /*************************************************************************
  296. Command response with no data packets
  297. *************************************************************************/
  298. static
  299. void sendDone(PSER_INFO pHWHead, int err)
  300. {
  301.     struct EP0ICSR1Bits EP0ICSR1;
  302.     BYTE index;
  303.     
  304.     EP0ICSR1 = pHWHead->pUSBCtrlAddr->EP0ICSR1;
  305.     EP0ICSR1.sopr_cdt   = 1;
  306.     EP0ICSR1.de_ff      = 1;
  307.     EP0ICSR1.sts_ur     = (BYTE)err;
  309.     // Endpoint 0 mode
  310.     index = pHWHead->pUSBCtrlAddr->INDEX.index;
  311.     pHWHead->pUSBCtrlAddr->INDEX.index = 0x0;
  313.     if (err) {
  314.         DEBUGMSG(ZONE_ERROR, (TEXT("SENT_STALL CLEARrn")));
  315.     }
  317.     UDC_REG_WRITEX( *(volatile DWORD *)&pHWHead->pUSBCtrlAddr->EP0ICSR1,
  318.                     *(DWORD *)&EP0ICSR1 );
  320.     pHWHead->pUSBCtrlAddr->INDEX.index = index;
  321. }
  323. /*************************************************************************
  324. Set the device address
  325. *************************************************************************/
  326. static
  327. void setAddress(PSER_INFO pHWHead, int addr)
  328. {
  329.     DEBUGMSG(ZONE_USB, (TEXT("[SET ADDRESS to %x]rn"), addr));
  331.     pHWHead->pUSBCtrlAddr->udcFAR.func_addr = (BYTE)addr;
  332.     pHWHead->pUSBCtrlAddr->udcFAR.addr_up = 1;
  333. }
  335. /*************************************************************************
  336. SC2440_USB_Init
  338. Initialize the UDC.
  339. *************************************************************************/
  340. extern
  341. void SC2440_USB_Init(PSER_INFO pHWHead)
  342. {
  343. BYTE index;
  344. int i;
  346.     EnterCriticalSection(&pHWHead->HwRegCritSec);
  348. USBDMSG(1, (TEXT("++SC2440_USB_Initrn")));
  349. //RETAILMSG(1, (TEXT("++SC2440_USB_Initrn")));
  351. //DebugBreak();;;
  352. pHWHead->dConfIdx    = 0;
  353. pHWHead->dSetting    = 0;
  354. pHWHead->dInterface  = 0;
  355. pHWHead->dAddress    = 0;
  356. pHWHead->ModemStatus = 0; // All lines low till we get connected.
  357. pHWHead->wSOFStableCnt = 0;
  359. _re_enable:
  360.     switch (pHWHead->State) {
  361.         case IDLE:
  362.             //RETAILMSG(1, (TEXT("IDLErn")));
  363.             //
  364.             // Enable the USB Clocks
  365.             //
  366. HW_USBClocks(pHWHead);
  367. break;
  369.         case OFF:
  370.             //RETAILMSG(1, (TEXT("OFFrn")));
  371.             //
  372.             // Disable the USB Clocks
  373.             //
  374. HW_USBClocks(pHWHead);
  376.             DEBUGMSG(ZONE_INIT, (TEXT("rUPLLCON: 0x%Xrn"), pHWHead->pCLKPWR->rUPLLCON));
  377.             goto _done;
  378.             break;
  380.         case SUSPEND:
  381.             // should never get here
  382.             //RETAILMSG(1, (TEXT("SUSPENDrn")));
  383. ASSERT(0);
  384.             goto _done;
  385.             break;
  387.         case RESUME:
  388.             // Suspend disconnects us from the USB.
  389.             // When we Resume we re-enumerate on the USB.
  390.             //RETAILMSG(1, (TEXT("RESUME => ")));
  392.         default:            
  393.             pHWHead->State = IDLE;
  394.             goto _re_enable;
  395.             break;
  396.     }
  397.     
  398.     //
  399.     // Initialize the USBD Controller
  400.     //
  401.     index = pHWHead->pUSBCtrlAddr->INDEX.index;
  402.     
  403.     // suspend mode disable
  404.     pHWHead->pUSBCtrlAddr->PMR.sus_en = 0x0;
  405.     ASSERT(pHWHead->pUSBCtrlAddr->PMR.sus_en == 0x0);
  407.     // setup endpoint 0
  408.     pHWHead->pUSBCtrlAddr->INDEX.index = 0;
  409.     ASSERT(pHWHead->pUSBCtrlAddr->INDEX.index == 0);
  411.     pHWHead->pUSBCtrlAddr->MAXP.maxp = 0x1;         // 8 BYTE
  412.     ASSERT(pHWHead->pUSBCtrlAddr->MAXP.maxp == 0x1);
  414.     pHWHead->pUSBCtrlAddr->EP0ICSR1.sopr_cdt = 1;   // OUT_PKT_RDY
  415.     //ASSERT(pHWHead->pUSBCtrlAddr->EP0ICSR1.sopr_cdt == 1); // W only
  417.     pHWHead->pUSBCtrlAddr->EP0ICSR1.sse_ = 1;       // SETUP_END
  418.     //ASSERT(pHWHead->pUSBCtrlAddr->EP0ICSR1.sse_ == 1); // W only
  420.     // setup endpoint 1
  421.     pHWHead->pUSBCtrlAddr->INDEX.index = 1;
  422.     ASSERT(pHWHead->pUSBCtrlAddr->INDEX.index == 1);
  423.         
  424.     pHWHead->pUSBCtrlAddr->MAXP.maxp = 0x8;     // 64 BYTE
  425.     ASSERT(pHWHead->pUSBCtrlAddr->MAXP.maxp == 0x8);
  426.     
  427.     pHWHead->pUSBCtrlAddr->ICSR2.mode_in = 1;   // IN
  428.     ASSERT(pHWHead->pUSBCtrlAddr->ICSR2.mode_in == 1);
  429.     
  430.     pHWHead->pUSBCtrlAddr->ICSR2.iso = 0;       // BULK
  431.     ASSERT(pHWHead->pUSBCtrlAddr->ICSR2.iso == 0);
  433.     // setup endpoint 4
  434.     pHWHead->pUSBCtrlAddr->INDEX.index = 4;
  435.     ASSERT(pHWHead->pUSBCtrlAddr->INDEX.index == 4);
  436.     
  437.     pHWHead->pUSBCtrlAddr->MAXP.maxp = 0x8;     // 64 BYTE
  438.     ASSERT(pHWHead->pUSBCtrlAddr->MAXP.maxp == 0x8);
  439.     
  440.     pHWHead->pUSBCtrlAddr->ICSR2.mode_in = 0;   // OUT
  441.     ASSERT(pHWHead->pUSBCtrlAddr->ICSR2.mode_in == 0);
  442.     
  443.     pHWHead->pUSBCtrlAddr->OCSR2.iso = 0;       // BULK
  444.     ASSERT(pHWHead->pUSBCtrlAddr->OCSR2.iso == 0);
  446.     // clear all EP interrupts
  447.     pHWHead->pUSBCtrlAddr->EIR.ep0_int = 0x1;
  448.     ASSERT(pHWHead->pUSBCtrlAddr->EIR.ep0_int == 0);
  449.     
  450.     pHWHead->pUSBCtrlAddr->EIR.ep1_int = 0x1;
  451.     ASSERT(pHWHead->pUSBCtrlAddr->EIR.ep1_int == 0);
  452.     
  453.     pHWHead->pUSBCtrlAddr->EIR.ep2_int = 0x1;
  454.     ASSERT(pHWHead->pUSBCtrlAddr->EIR.ep2_int == 0);
  455.     
  456.     pHWHead->pUSBCtrlAddr->EIR.ep3_int = 0x1;
  457.     ASSERT(pHWHead->pUSBCtrlAddr->EIR.ep3_int == 0);
  458.         
  459.     pHWHead->pUSBCtrlAddr->EIR.ep4_int = 0x1;
  460.     ASSERT(pHWHead->pUSBCtrlAddr->EIR.ep4_int == 0);
  462.     // clear reset int
  463.     pHWHead->pUSBCtrlAddr->UIR.reset_int = 0x1;
  464.     ASSERT(pHWHead->pUSBCtrlAddr->UIR.reset_int == 0x0);
  466.     // EP0, 1, & 4 Enabled, EP2, 3 Disabled
  468.     pHWHead->pUSBCtrlAddr->EIER.ep2_int_en = 0x0;
  469.     ASSERT(pHWHead->pUSBCtrlAddr->EIER.ep2_int_en == 0x0);
  470.     
  471.     pHWHead->pUSBCtrlAddr->EIER.ep3_int_en = 0x0;
  472.     ASSERT(pHWHead->pUSBCtrlAddr->EIER.ep3_int_en == 0x0);
  474.     pHWHead->pUSBCtrlAddr->EIER.ep0_int_en = 0x1;
  475.     ASSERT(pHWHead->pUSBCtrlAddr->EIER.ep0_int_en == 0x1);
  476.     
  477.     pHWHead->pUSBCtrlAddr->EIER.ep1_int_en = 0x1;
  478.     ASSERT(pHWHead->pUSBCtrlAddr->EIER.ep1_int_en == 0x1);
  479.     
  480.     pHWHead->pUSBCtrlAddr->EIER.ep4_int_en = 0x1;
  481.     ASSERT(pHWHead->pUSBCtrlAddr->EIER.ep4_int_en == 0x1);
  483.     // enable reset int 
  484.     pHWHead->pUSBCtrlAddr->UIER.reset_int_en = 0x1;
  485.     ASSERT(pHWHead->pUSBCtrlAddr->UIER.reset_int_en == 0x1);
  488. if(v_pDMAregs==NULL)
  489. {
  490. //RETAILMSG(1, (TEXT("ERROR: SC2440_usb_hw: v_pDMAregs=NULLrn")));
  491. while(1);
  492. }
  494. pHWHead->pUSBCtrlAddr->INDEX.index = 0x4;
  496. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DC=0x0; 
  497.     //may not be needed, not to operate DMA during initialization.
  498. UsbdInitDma3(0,0);
  500. usbdShMem->usbdRxRdPt=0;
  501. usbdShMem->usbdRxWrPt=0;
  502. usbdShMem->usbdRxCnt=0;
  503. usbdShMem->usbdEir=0;
  504.   usbdShMem->usbdUir=0;
  505. usbdShMem->usbdDma3Int=0; 
  507.     //rEP4_DMA_FIFO=0x40; //not needed for OUT operation.
  509. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DTL=USBD_GLOBALS_BUF_SIZE&0xff;
  510. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DTM=(USBD_GLOBALS_BUF_SIZE>>8)&0xff;
  511. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DTH=(USBD_GLOBALS_BUF_SIZE>>16)&0x0f;
  513. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->OCSR2=
  514. *(BYTE *)&pHWHead->pUSBCtrlAddr->OCSR2 | (BYTE)EPO_AUTO_CLR /*| EPO_OUT_DMA_INT_MASK*/;  
  515. //AUTO_CLR(OUT_PKT_READY is cleared automatically), interrupt_masking.
  517. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DU=0x01; //DMA transfer unit=1byte
  518. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DC=UDMA_OUT_DMA_RUN|UDMA_DMA_MODE_EN;
  519. //deamnd disable,out_dma_run=run,in_dma_run=stop,DMA mode enable
  521. //wait until DMA_CON is effective.
  522. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DC;
  523. for(i=0;i<10;i++);   
  526. v_pINTregs->rINTMSK&=~(BIT_DMA3);  //enable DMA3 interrupt
  528. pHWHead->pUSBCtrlAddr->INDEX.index = 0x0; //del me
  530. _done:
  531. LeaveCriticalSection(&pHWHead->HwRegCritSec);
  532.     
  533. USBDMSG(1, (TEXT("--SC2440_USB_Initrn")));
  534. //RETAILMSG(1, (TEXT("--SC2440_USB_Initrn")));
  535. }
  537. /*************************************************************************
  538. Process Endpoint 0 interrupt. We are called here on every EIR interrupt.
  539. We need to check the EP0 status and send the next packet, if any. We need
  540. to handle errors as follows:
  542. SE - This is set if we received a new command before we finished the last
  543. one. This happens when the host does not wish to read all reply data
  544. (it may only be interested in the first 8 bytes of a device descriptor
  545. to get the max packet size, for example). We will simply discard the
  546. next data to send and continue with the normal command handling. We
  547.   need to clear SE by asserting SSE before we continue.
  548.  
  549. SST - This is set when the UDC actually issues a stall. We just clear it
  550. and continue.
  552.  Normal setup is as follows:
  554.  OPR - This indicates a receive command packet is ready to be read. Commands
  555. are always 8 bytes in length and follow the form defined in chapter 9.
  557.  If OPR is not set and IPR is not set and SE is not set we must be here
  558.  because IPR transitioned from 1 -> 0. This means the last packet has been
  559.  sent (ACK'd). Send the next packet, if any.
  561.  We are emulating a serial line here. The state of the modem control lines
  562.  are sent in a command packet. Extract these and set the modem status bits
  563.  as for a normal serial line. This allows the upper levels to treat this
  564.  link just like a serial line with modem control (no flow control is
  565.  explicitly required and hence is not supported.
  566. **************************************************************************/
  567. void SC2440_USB_DoEndpoint0(PSER_INFO pHWHead, PDWORD pModemStatus)
  568. {
  569. BYTE dbuf[8];
  570. WORD len, totLen;
  571. PUCHAR p;
  572. unsigned int cnt=0;
  574. struct EP0ICSR1Bits EP0ICSR1=pHWHead->pUSBCtrlAddr->EP0ICSR1;
  576. // Endpoint 0 mode
  577. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x0); 
  579. DEBUGMSG(1, (TEXT("++SC2440_USB_DoEndpoint0rn")));
  580. //RETAILMSG(1, (TEXT("++SC2440_USB_DoEndpoint0rn")));
  582. /* If there is data to send and the transmitter is open go send
  583. * the next packet. But, do not continue to send if the host has
  584. * aborted the transfer or sent a new one. We'll clean up below.
  585. */
  586. if ((EP0ICSR1.se_sds == 0) && (EP0ICSR1.ipr_ == 0) && 
  587. (EP0ICSR1.opr_ipr == 0) && (sendPacket))
  588. {
  589. DEBUGMSG( 1, (TEXT("Send remaining data !!!rn")));
  591. sendData(pHWHead, sendPacket, sendPacketLength, sendTotalLength);
  592. }
  594. // If setup end, the host has aborted the last transfer. Kill any
  595. //remaining packets and continue;
  596. if (EP0ICSR1.se_sds) {
  597. sendPacketLength = 0;
  598. sendPacket = NULL;
  599. UDC_REG_BITSET(struct EP0ICSR1Bits, &pHWHead->pUSBCtrlAddr->EP0ICSR1, sse_, 1); 
  600. }
  602. // If stall ack, not sure what needs to be done here.
  603. if (EP0ICSR1.sts_ur) 
  604. {
  605. DEBUGMSG( 1, (TEXT("Stall ACK setrn")));
  606. UDC_REG_BITSET(struct EP0ICSR1Bits, &pHWHead->pUSBCtrlAddr->EP0ICSR1, sts_ur, 0);  // 0 -> clear
  607. }
  609. // If new command received ...
  611. DEBUGMSG(1, (TEXT("OUT_PKT_RDY = 0x%xrn"), EP0ICSR1.opr_ipr));
  612. // if (EP0ICSR1.opr_ipr) 
  613. if (EP0ICSR1.opr_ipr)
  614. {
  616. // New command with existing data. Not sure how this can happen but if
  617. // it does just clear the old data and continue.
  618. if (sendPacket)
  619.   sendPacket = NULL;
  621. cnt = pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low | pHWHead->pUSBCtrlAddr->OFCR2.out_cnt_high << 8; 
  622. DEBUGMSG(1,(TEXT("UDC received setup, EP0ICSR1 %x, len %dn"), 
  623. EP0ICSR1, cnt));
  625. // Read the command from the input FIFO
  626. if (getCommand(pHWHead, (void*)&pHWHead->dReq) != 0) 
  627. {
  628. sendDone(pHWHead,1);
  629. }
  631. DEBUGMSG(1, 
  632. (TEXT("bmRequest: %02x bRequest: %02x wValue: %04x wIndex: %04x wLength: %04xn"), 
  633. pHWHead->dReq.bmRequest,
  634. pHWHead->dReq.bRequest,
  635. pHWHead->dReq.wValue,
  636. pHWHead->dReq.wIndex,
  637. pHWHead->dReq.wLength));
  639. // Decode and execute the command. We support two sets of commands, vendor
  640. // specific (modem control) and chapter 9 standard commands.
  641. if (pHWHead->dReq.bmRequest & 0x60) // vendor or class command
  642. { 
  643. DEBUGMSG(1, (TEXT("Vendor/Class Command !!n")));
  645. if (SET_CONTROL_LINE_STATE == pHWHead->dReq.bRequest) 
  646. {
  647. // Host is notifying us of control line state.
  648. // wValue contains bitmask
  649. // 0 - DTR
  650. // 1 - RTS
  651. DEBUGMSG(1, (TEXT("SET_CONTROL_LINE_STATE %4.4Xrn"),
  652. pHWHead->dReq.wValue));
  654. if (pHWHead->dReq.wValue & 0x01)
  655. *pModemStatus |= (MS_DSR_ON|MS_RLSD_ON);  // DTR active, set DSR/RLSD
  656. else
  657. *pModemStatus &= ~(MS_DSR_ON|MS_RLSD_ON); // DTR clear, clr DSR/RLSD
  658.         
  659. if (pHWHead->dReq.wValue & 0x02) 
  660. *pModemStatus |= MS_CTS_ON;   // RTS active, set CTS
  661. else
  662. *pModemStatus &= ~MS_CTS_ON;   // RTS clear, clear CTS
  663. }
  664. else {
  665. // Unknown vendor/class request
  666. DEBUGMSG(1,(TEXT("Unknown vendor/class request %2.2Xrn"),
  667. pHWHead->dReq.bRequest));
  668. }
  670. // Command is complete
  671. sendDone(pHWHead,0);
  672. return;
  673. }
  675. // standard chapter 9 commands
  676. switch (pHWHead->dReq.bRequest) {
  677. case GET_STATUS:
  678. RETAILMSG(1, (TEXT("GET_STATUSrn")));
  680. dbuf[0] = 0;
  681. dbuf[1] = 0;
  683. // If this is a request to the endpoint return the stalled status.
  684. if (pHWHead->dReq.bmRequest == 0x82) {
  685. dbuf[0] = 0;
  686. switch (pHWHead->dReq.wIndex & 15) {
  688. // Control endpoint can't stall (we wouldn't get this message).
  689. case 0:
  690. break;
  691.   
  692. // OUT endpoint. Return send_stall.
  693. case 1:
  694. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x4); 
  695. if (pHWHead->pUSBCtrlAddr->OCSR1.send_stall)
  696. dbuf[0] = 1;
  697. break;
  699. // IN endpoint. Return send_stall.
  700. case 2:
  701. //case 3:
  702. case 4:
  703. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x1); 
  704. if (pHWHead->pUSBCtrlAddr->EP0ICSR1.se_sds)
  705. dbuf[0] = 1;
  706. break;
  707. }
  708. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0);
  709. }
  711. // Clear the OPR bit and start the data phase
  712. sendCommandDone(pHWHead);
  714. // Send the reply data.
  715. sendData(pHWHead, dbuf, 2, 2);
  716. //RETAILMSG(1, (TEXT("GS[0x%X]rn"), pHWHead->dReq.wIndex & 0xFF));
  717. break;
  719. case CLEAR_FEATURE:
  720. DEBUGMSG(1, (TEXT("CLEAR_FEATURErn")));
  722. if (pHWHead->dReq.bmRequest == 0x02) { // Halt 
  723. switch (pHWHead->dReq.wIndex & 15) {
  724. // Control endpoint. Not suggested.
  725. case 0:
  726. break;
  728. // OUT endpoint. Set and clear sendstall to reset DATA0/DATA1.
  729. case 1:
  730. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x4); 
  731. UDC_REG_BITSET(struct OCSR1Bits,
  732. &pHWHead->pUSBCtrlAddr->OCSR1,send_stall,1); // STALL!!!
  733. UDC_REG_BITSET(struct OCSR1Bits,
  734. &pHWHead->pUSBCtrlAddr->OCSR1,send_stall,0);
  735. UDC_REG_BITSET(struct OCSR1Bits,
  736. &pHWHead->pUSBCtrlAddr->OCSR1,sent_stall,0); // CLEAR STALL
  737. break;
  739. // IN endpoint. Set and clear sendstall to reset DATA0/DATA1.
  740. case 2:
  741. //case 3:
  742. case 4:
  743. UDC_REG_WRITE(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x1); 
  744. UDC_REG_BITSET(struct EP0ICSR1Bits,
  745. &pHWHead->pUSBCtrlAddr->EP0ICSR1,se_sds,1); // STALL!!!
  746. UDC_REG_BITSET(struct EP0ICSR1Bits,
  747. &pHWHead->pUSBCtrlAddr->EP0ICSR1,se_sds,0);
  748. UDC_REG_BITSET(struct EP0ICSR1Bits,
  749. &pHWHead->pUSBCtrlAddr->EP0ICSR1,sds_sts,0); // CLEAR STALL
  750. break;
  751. }
  752. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0);
  753. }
  755. // Command is complete
  756. sendDone(pHWHead,0);
  757. //RETAILMSG(1, (TEXT("CF[0x%X]rn"), pHWHead->dReq.wIndex & 0xFF));
  758. break;
  760. case SET_FEATURE:
  761. DEBUGMSG(1, (TEXT("SET_FEATURE %drn"), pHWHead->dReq.bmRequest));
  763. if (pHWHead->dReq.bmRequest == 0x02) {
  764. switch (pHWHead->dReq.wIndex & 15) {
  765. // Control endpoint. Not suggested.
  766. case 0:
  767. break;
  769. /* OUT endpoint. Set sendstall to force stall condition
  770. */
  771. case 1:
  772. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x4); 
  773. UDC_REG_BITSET(struct OCSR1Bits,
  774. &pHWHead->pUSBCtrlAddr->OCSR1, send_stall, 1); // STALL
  775. break;
  777. /* IN endpoint. Set sendstall to force stall condition
  778. */
  779. case 2:
  780. //case 3:
  781. case 4:
  782. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x1); 
  783. UDC_REG_BITSET(struct EP0ICSR1Bits, 
  784. &pHWHead->pUSBCtrlAddr->EP0ICSR1, se_sds, 1); // STALL
  785. break;
  786. }
  787. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0);
  788. }
  790. // Command is complete
  791. sendDone(pHWHead,0);
  792. //RETAILMSG(1, (TEXT("SF[0x%X]rn"), pHWHead->dReq.wIndex & 0xFF));
  793. break;
  795. case SET_ADDRESS:
  796. RETAILMSG(1, (TEXT("SET_ADDRESS - 0x%Xrn"), pHWHead->dReq.wValue));
  798. pHWHead->dAddress = (BYTE)pHWHead->dReq.wValue;
  800. // Note, this write needs to be started here but it will not read back
  801. // until the command completes. There is no retry mechanism.
  802. setAddress(pHWHead, pHWHead->dAddress);
  804. // Command is complete
  805. sendDone(pHWHead,0);
  806. break;
  808. case GET_DESCRIPTOR:
  809. switch ((BYTE)(pHWHead->dReq.wValue>>8)) {
  810. case DEVICE: // 0x01
  811. RETAILMSG(1, (TEXT("GET_DESCRIPTOR:DEVICE 0x%X, 0x%Xrn"), 
  812. uStd[0], pHWHead->dReq.wLength));
  813. //sendCommandDone(pHWHead);
  814. p = (PUCHAR)uStd;
  815. len = (BYTE)min(uStd[0],pHWHead->dReq.wLength);
  816. totLen = uStd[0];
  817. break;
  819. case CONFIGURATION: // 0x02
  820. RETAILMSG(1,(TEXT("GET_DESCRIPTOR:CONFIGURATIONrn")));
  821. //sendCommandDone(pHWHead);
  822. p = (PUCHAR)&uStd[iCONF];
  823. len = (BYTE)min(CFGLEN,pHWHead->dReq.wLength);
  824. totLen = CFGLEN;
  825. break;
  827. case STRING: // 0x03
  828. DEBUGMSG(1,(TEXT("GET_DESCRIPTOR:STRINGrn")));
  829. //sendCommandDone(pHWHead);
  830. p = NULL;
  831. len = 0;
  832. totLen = 0;
  833. break;
  835. default:
  836. DEBUGMSG(1,(TEXT("GET_DESCRIPTOR:Unknown %drn"),
  837. (pHWHead->dReq.wValue>>8) ));
  838. sendCommandDone(pHWHead);
  839. p = NULL;
  840. len = 0;
  841. totLen = 0;
  842. break;
  844. }
  846. // Clear the OPR bit and start the data phase
  847. sendCommandDone(pHWHead);
  849. // Send the reply data.
  850. sendData(pHWHead, p, len, totLen);
  851. DEBUGMSG(1,(TEXT("GET_DESCRIPTOR:EP0ICSR1 status value = 0x%xrn"), pHWHead->pUSBCtrlAddr->EP0ICSR1));
  852. break;
  854. case GET_CONFIG:
  855. RETAILMSG(1, (TEXT("GET_CONFIGrn")));
  857. // Clear the OPR bit and start the data phase
  858. sendCommandDone(pHWHead);
  860. // Send the reply data.
  861. sendData(pHWHead, &pHWHead->dConfIdx, 1, 1);
  862. break;
  864. case GET_INTERFACE:
  865. DEBUGMSG(1,(TEXT("GET_INTERFACErn")));
  867. // Clear the OPR bit and start the data phase
  868. sendCommandDone(pHWHead);
  870. // Send the reply data.
  871. sendData(pHWHead, &pHWHead->dInterface, 1, 1);
  872. break; 
  874. case SET_CONFIG:
  875. RETAILMSG(1,(TEXT("SET_CONFIG %drn"),
  876. pHWHead->dReq.wValue));
  877. pHWHead->dConfIdx = (BYTE)pHWHead->dReq.wValue;
  879. // Command done
  880. sendDone(pHWHead,0);
  881. break;
  883. case SET_DESCRIPTOR:
  884. RETAILMSG(1, (TEXT("SET_DESCRIPTORrn")));
  886. // Command done
  887. sendDone(pHWHead,0);
  888. break;
  890. case SET_INTERFACE:
  891. DEBUGMSG(1,(TEXT("SET_INTERFACE : %d,%drn"),
  892. pHWHead->dReq.wIndex,
  893. pHWHead->dReq.wValue));
  894. pHWHead->dInterface = (BYTE)pHWHead->dReq.wIndex;
  895. pHWHead->dSetting = (BYTE)pHWHead->dReq.wValue;
  897. // Command done
  898. sendDone(pHWHead,0);
  899. break;
  901. default:
  902. DEBUGMSG(1,(TEXT("Unhandled Command : %drn"),
  903. pHWHead->dReq.bRequest));
  905. // Command done
  906. sendDone(pHWHead,0);
  907. break;
  908. }
  909. }
  911. DEBUGMSG(1, (TEXT("--SC2440_USB_DoEndpoint0rn")));
  912. }
  914. /*************************************************************************
  915. SC2440_USB_GetInterruptType
  917. Determine the source of an interrupt and return flags to control 
  918. which function gets called to handle it. EP0 is handled as modem 
  919. interrupt, EP1 as TX, EP3 as RX and reset is handle as line 
  920. interrupt.
  921. *************************************************************************/
  923. INTERRUPT_TYPE SC2440_USB_GetInterruptType( PSER_INFO pHWHead) //:-)
  924. {
  925. INTERRUPT_TYPE interruptFlags = 0;
  926. //BYTE saveIndex;
  928.     pHWHead->wPrevSOF = pHWHead->wSOF;
  929.     pHWHead->wSOF = (pHWHead->pUSBCtrlAddr->FNR2.fr_n2 << 8) | pHWHead->pUSBCtrlAddr->FNR1.fr_n1; 
  930. DEBUGMSG(1, (TEXT("SOF: %u, wPrevSOF: %urn"), pHWHead->wSOF, pHWHead->wPrevSOF));
  931. //RETAILMSG(1, (TEXT("SOF: %u, wPrevSOF: %urn"), pHWHead->wSOF, pHWHead->wPrevSOF));
  933. //important notes
  934. // 1. INDEX register should be preserved here. //:-)
  935. // 2. 'else if' should not be used here. //:-) 
  937. if (usbdShMem->usbdEir& USBDEIR_EP1) // EP1(IN), ready to TX more data.
  938. {
  939. interruptFlags |= INTR_TX;
  940. }
  941.   if (usbdShMem->usbdEir& USBDEIR_EP4) // EP4(OUT), RX data ready
  942. {
  943. interruptFlags |= INTR_RX;
  944. }
  946. if (usbdShMem->usbdDma3Int) // DMA3 done interrupt
  947. {
  948. interruptFlags |= INTR_RX;
  949. USBDMSG(1, (TEXT("<D3Int>rn")));
  950. }
  952. if (usbdShMem->usbdUir& USBDUIR_RESET)// USB reset, so re-initialize our driver.
  953. {
  954. USBDMSG(1, (TEXT("RESET INTrn")));
  955. interruptFlags |= INTR_LINE; // We use INTR_LINE to handle USB Reset 
  956. usbdShMem->usbdUir&=~USBDUIR_RESET;
  957. }
  959. if (usbdShMem->usbdEir&USBDEIR_EP0) // EP0, Control endpoint
  960. {
  961. interruptFlags |= INTR_MODEM; // Use INTR_MODEM for EP0 interrupts
  962. // call SerModemIntr function  by shim 020503
  963. usbdShMem->usbdEir&=~USBDEIR_EP0;
  964. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX=0x0;  
  965. //temp_kiw, should be repaired officially.
  966. USBDMSG(1, (TEXT("<EP0 Int>rn")));
  967. }
  969. return (interruptFlags);
  970. }
  972. /*************************************************************************
  973. SC2440_USB_LineIntHandler
  975. This handler is called for reset interrupts
  976. *************************************************************************/
  977. void SC2440_USB_LineIntHandler(PSER_INFO pHWHead)
  978. {
  979. DEBUGMSG(1, (TEXT("++SC2440_USB_LineIntHandlerrn")));
  981. SC2440_USB_Init(pHWHead);
  982. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0);
  984. DEBUGMSG(1, (TEXT("--SC2440_USB_LineIntHandlerrn")));
  985. }
  987. /*************************************************************************
  988.   SC2440_USB_RxIntHandler
  989.  
  990.   Read characters up to the max packet length from the IN FIFO. Return the
  991.   number of characters read in the supplied argument. The function returns
  992.   a boolean indicating whether event characters are present.
  993. *************************************************************************/
  996. BOOL SC2440_USB_RxIntHandler(PSER_INFO pHWHead,
  997.      PUCHAR pRxBuffer,
  998.      ULONG *pBuffLen)
  999. {
  1000. BOOL fRXFlag    = FALSE;
  1001. UCHAR cEvtChar    = pHWHead->dcb.EvtChar;
  1002. int buflen    = *pBuffLen;
  1003. UCHAR cRxChar;
  1004. ULONG usbdRxRdPt=0;
  1005. ULONG usbdRxWrPt=0;
  1006. ULONG usbdRxCnt;
  1007. BYTE* usbdRxBuf;
  1008. ULONG cnt,saveCnt;
  1009. int   swRdCnt=0;
  1010. BYTE saveIndex;
  1011. DEBUGMSG(1, (TEXT("++SC2440_USB_RxIntHandlerrn")));
  1012.     
  1013. usbdRxRdPt=usbdShMem->usbdRxRdPt;
  1014. usbdRxBuf=(BYTE*)usbdShMem->usbdRxBuf;
  1015. *pBuffLen = 0;
  1016.     
  1017. // Endpoint 4 mode
  1018. saveIndex=*(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX;
  1019. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX=0x4;
  1021. if (usbdShMem->usbdDma3Int)
  1022. {
  1024. //usbdRxWrPt=v_pDMAregs->rDCDST3 - realPhysicalAddr_UsbdRxBuf;
  1025. USBDMSG(1,(TEXT("[RxPt:%d]"),usbdRxRdPt));
  1026. if(usbdRxRdPt==0)
  1027. {
  1028. usbdShMem->usbdDma3Int=0;
  1030. USBDMSG(1,(TEXT("[D:%d"),pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low));
  1031. // cnt=swRdCnt=pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low | pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_high;
  1032. swRdCnt=pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low | pHWHead->pUSBCtrlAddr->OFCR2.out_cnt_high;
  1033. for(cnt=0; cnt < swRdCnt; cnt++)
  1034. {
  1035. usbdRxBuf[cnt]=(UCHAR)pHWHead->pUSBCtrlAddr->EP4F.fifo_data;
  1036. }
  1037. if((pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low | pHWHead->pUSBCtrlAddr->OFCR2.out_cnt_high)==0 && 
  1038.    pHWHead->pUSBCtrlAddr->OCSR1.out_pkt_rdy==1)
  1039. {
  1040. USBDMSG(1, (TEXT(",OPR CLR,")));
  1041. UDC_REG_BITSET(struct OCSR1Bits,&pHWHead->pUSBCtrlAddr->OCSR1, out_pkt_rdy, 0);
  1042. }
  1044. UsbdInitDma3(0,swRdCnt); 
  1045. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DTL=(USBD_GLOBALS_BUF_SIZE-swRdCnt)&0xff;
  1046. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DTM=((USBD_GLOBALS_BUF_SIZE-swRdCnt)>>8)&0xff;
  1047. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DTH=((USBD_GLOBALS_BUF_SIZE-swRdCnt)>>16)&0x0f;
  1048. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->EP4DC=UDMA_OUT_DMA_RUN|UDMA_DMA_MODE_EN;
  1049. }
  1051. }
  1053. usbdRxWrPt=v_pDMAregs->rDCDST3 - realPhysicalAddr_UsbdRxBuf;
  1054. if(usbdRxWrPt==USBD_GLOBALS_BUF_SIZE)
  1055. {
  1056. usbdRxWrPt=swRdCnt;
  1057. //usbdRxWrPt=0;
  1058. }
  1060. if(usbdRxRdPt<=usbdRxWrPt)
  1061. usbdRxCnt=usbdRxWrPt-usbdRxRdPt;
  1062. else
  1063. usbdRxCnt=USBD_GLOBALS_BUF_SIZE-usbdRxRdPt+usbdRxWrPt;
  1065. if( buflen > usbdRxCnt)
  1066. saveCnt=cnt=usbdRxCnt;
  1067. else
  1068. saveCnt=cnt=buflen;
  1070. if (usbdRxCnt == 0) // No data to read
  1071. { 
  1072. USBDMSG(1, (TEXT("[R0]")));
  1073. }  
  1074. else
  1075. {
  1077. USBDMSG(1, (TEXT("<%d>"),cnt));
  1079. while(cnt--) 
  1080. {
  1081. *pRxBuffer++ = cRxChar = (UCHAR)usbdRxBuf[usbdRxRdPt++];
  1082. if(usbdRxRdPt==USBD_GLOBALS_BUF_SIZE)
  1083. usbdRxRdPt=0;
  1084. if( cRxChar == cEvtChar )
  1085. fRXFlag = TRUE;
  1086. }
  1088. (*pBuffLen)=saveCnt;
  1089. usbdRxCnt-=saveCnt;
  1091. usbdShMem->usbdRxRdPt=usbdRxRdPt;
  1092. usbdShMem->usbdEir&=~USBDEIR_EP4;
  1093. }
  1095.     //not be needed. Only for test
  1096. if(pHWHead->pUSBCtrlAddr->OFCR1.out_cnt_low==0 ) 
  1097. if(pHWHead->pUSBCtrlAddr->OCSR1.out_pkt_rdy==1)
  1098. {
  1099.     USBDMSG(1, (TEXT("__OPR__(NEVER EXECUTED)")));
  1100. UDC_REG_BITSET(struct OCSR1Bits,&pHWHead->pUSBCtrlAddr->OCSR1, out_pkt_rdy, 0);
  1101. }
  1103. // If we didn't read the whole buffer we need to come back. Leave with
  1104. // the interrupt still enabled so the MDD will recall.
  1105. if (usbdRxCnt>0)
  1106. {
  1107. USBDMSG(1, (TEXT("[%d->MDD]"),usbdRxCnt));
  1108. usbdShMem->usbdEir|=USBDEIR_EP4; 
  1109. // MDD will recall RxIntHandler by chekcing SC2440_USB_GetInterruptType().
  1110. // So, usbdShMem->usbdEir:USBDEIR_EP3 must not be cleared //:-) 
  1111. //Sleep(100);
  1113. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX=saveIndex;
  1114. return fRXFlag;
  1115. }
  1116. usbdShMem->usbdEir&=~USBDEIR_EP4;
  1117. DEBUGMSG(1, (TEXT("--SC2440_USB_RxIntHandlerrn")));
  1119. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX=saveIndex;
  1120. return fRXFlag;
  1121. }
  1126. /*************************************************************************
  1127.   SC2440_USB_TxIntHandler
  1128.  
  1129.   Send the next packet to the USB. The first packet gets sent by directly
  1130.   calling this function (via dispatch table) from the MDD. After the first
  1131.   call the interrupt mechanism will keep things going.
  1132.  
  1133.   We return the actual number of bytes we've queued to the UDC. Note that
  1134.   until the next interrupt we wont know if it has been transmitted. We'll
  1135.   deal with the failure by saving the original packet and retransmitting if
  1136.   we get an error. In that case we'll return 0 as the number of bytes sent
  1137.   since no new bytes have been consumed from the caller's buffer.
  1138.  
  1139.   When the packet is accepted we return the number of bytes and grab the 
  1140.   next packet (or portion thereof).
  1141.  
  1142. *************************************************************************/
  1143. //:-)
  1144. void SC2440_USB_TxIntHandler( PSER_INFO pHWHead,
  1145.       PUCHAR pTxBuffer,
  1146.       ULONG *pBuffLen ) 
  1147. {
  1148. unsigned int i;
  1149. UCHAR ucLen;
  1150. BYTE saveIndex;
  1152. //DEBUGMSG(1, (TEXT("++SC2440_USB_TxIntHandlerrn")));
  1154. //USBDMSG(1, (TEXT("<T:%d>"),*pBuffLen));
  1156. usbdShMem->usbdEir&=~USBDEIR_EP1;
  1158. // Endpoint 1 mode
  1159. saveIndex=*(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX;
  1160. UDC_REG_BITSET(struct INDEXBits, &pHWHead->pUSBCtrlAddr->INDEX, index, 0x1);
  1161.     //pHWHead->pUSBCtrlAddr->INDEX.index=0x1; //:-)
  1163. pHWHead->CommErrors &= ~CE_TXFULL;
  1165. // If nothing to send, just return after clearing interrupt.
  1166. if (! *pBuffLen ) 
  1167. {
  1168. //DEBUGMSG (1, (TEXT("[TX:nothing to send]")));    
  1169. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX=saveIndex;
  1170. return;
  1171. }
  1172.            
  1173. // Don't try to send more than EP1 can handle.
  1174. if( *pBuffLen > EP1Len )
  1175.      ucLen = EP1Len;
  1176. else {
  1178. // If we end exactly on a packet boundary, the host doesn't
  1179. // realize there is no more data.  So if we exactly fill the final 
  1180. // packet, truncate it so we can send a short packet next frame
  1181. // indicating end of the transmission
  1182. if( *pBuffLen == EP1Len ) 
  1183. {
  1184. //USBDMSG (1, (TEXT("Tx breaking packetrn")));            
  1185. ucLen = EP1Len - 2;
  1186. } else {
  1187. ucLen = (UCHAR)*pBuffLen;
  1188. }
  1190. }
  1192. if (!pHWHead->pUSBCtrlAddr->EP0ICSR1.opr_ipr)
  1193. {
  1194. // Write to the FIFO directly to send the bytes.
  1195. for (i=0; i < ucLen; i++) 
  1196. {
  1197. IOW_REG_FIELD(struct EP1FBits, 
  1198. &pHWHead->pUSBCtrlAddr->EP1F, fifo_data, *pTxBuffer++);
  1199. }
  1201. // Return number of bytes transmitted via pBuffLen.
  1202. *pBuffLen = ucLen;
  1203. UDC_REG_WRITE(struct EP0ICSR1Bits, &pHWHead->pUSBCtrlAddr->EP0ICSR1, opr_ipr, 1);
  1204. } else {
  1205. // Transmit already in progress.  Just return and wait for current
  1206. // transmission to complete before sending more.
  1207. //USBDMSG(0, (TEXT("Write Pend !!!rn")));
  1208. *pBuffLen = 0; 
  1209. }
  1211. //DEBUGMSG(0, (TEXT("--SC2440_USB_TxIntHandlerrn")));
  1212. *(volatile BYTE *)&pHWHead->pUSBCtrlAddr->INDEX=saveIndex;
  1213. }
  1217. BOOL
  1218. HW_PowerOff(
  1219.     PSER_INFO pHWHead 
  1220.     )
  1221. {
  1222. pHWHead->State = OFF;
  1223. // cache the interrupt regs
  1224. pHWHead->cIntStat_uir = *(BYTE *)&pHWHead->pUSBCtrlAddr->UIR;
  1225. pHWHead->cIntStat_eir = *(BYTE *)&pHWHead->pUSBCtrlAddr->EIR;
  1226.     
  1227. // disable the USB Clocks
  1228. EnterCriticalSection(&pHWHead->HwRegCritSec);
  1229. //DEBUGMSG(1, (TEXT("USB:HW_PowerOff()rn")));
  1230. //RETAILMSG(1, (TEXT("USB:HW_PowerOff()rn")));
  1231. HW_USBClocks(pHWHead);
  1232. LeaveCriticalSection(&pHWHead->HwRegCritSec);
  1234.     return TRUE;
  1235. }
  1238. BOOL 
  1239. HW_PowerOn(
  1240.     PSER_INFO pHWHead
  1241.     )
  1242. {
  1244. pHWHead->State = RESUME;
  1246. // enable the USB Clocks
  1247. EnterCriticalSection(&pHWHead->HwRegCritSec);
  1248. //DEBUGMSG(1, (TEXT("USB:HW_PowerOn()rn")));
  1249. //RETAILMSG(1, (TEXT("USB:HW_PowerOn()rn")));
  1250. HW_USBClocks(pHWHead);
  1251. LeaveCriticalSection(&pHWHead->HwRegCritSec);
  1253. SetInterruptEvent(pHWHead->pHWObj->dwIntID); 
  1254.     
  1255.     return TRUE;
  1256. }
  1260. VOID
  1261. HW_USBClocks(PSER_INFO pHWHead)
  1262. {
  1263. if ((pHWHead->State == IDLE) || (pHWHead->State == RESUME))
  1264. {
  1265. DEBUGMSG(1, (TEXT("HW_USBClocks::IDLErn")));
  1266.         //
  1267.         // Enable the USB Clocks
  1268.         //
  1269.         pHWHead->pCLKPWR->rCLKCON |= (1<<7);
  1270.         DEBUGMSG(ZONE_INIT, (TEXT("rCLKCON: 0x%Xrn"), pHWHead->pCLKPWR->rCLKCON));
  1271.         
  1272.         // Fin=12MHz, Fout=48MHz
  1273.         //pHWHead->pCLKPWR->rUPLLCON = 0x48032;   // ((0x48 << 12) + (0x3 << 4) + 0x2)
  1274.         //DEBUGMSG(ZONE_INIT, (TEXT("rUPLLCON: 0x%Xrn"), pHWHead->pCLKPWR->rUPLLCON));
  1276.         //
  1277.         // MISCCR: USBD Pads, Normal mode
  1278.         //
  1279.         pHWHead->pIrqCtrlAddr->rMISCCR &= ~((3 << 12) | (1 << 3));
  1281.         // TO DO :
  1282.         // Enable USB_PULLUP on GPIO PIN (tied to USB D+) & set high
  1283.         //
  1285.         //pHWHead->pIrqCtrlAddr->rGPBCON &= ~(3 << 18);    // clear GPE15
  1286.         //pHWHead->pIrqCtrlAddr->rGPBCON |=  (1 << 18);    // config as output
  1287.         //pHWHead->pIrqCtrlAddr->rGPBUP  &= ~(1 << 9);    // pullup disabled
  1288.         //pHWHead->pIrqCtrlAddr->rGPBDAT |=  (1 << 9);    // set high
  1290.         pHWHead->pIrqCtrlAddr->rGPGCON &= ~(3 << 24);    // clear GPE15
  1291.         pHWHead->pIrqCtrlAddr->rGPGCON |=  (1 << 24);    // config as output
  1292.         pHWHead->pIrqCtrlAddr->rGPGUP  &= ~(1 << 12);    // pullup disabled
  1293.         pHWHead->pIrqCtrlAddr->rGPGDAT |=  (1 << 12);    // set high
  1295.         DEBUGMSG(ZONE_INIT, (TEXT("rGPDCON: 0x%Xrn"), pHWHead->pIrqCtrlAddr->rGPDCON));
  1296.         DEBUGMSG(ZONE_INIT, (TEXT("rGPDUP: 0x%Xrn"),  pHWHead->pIrqCtrlAddr->rGPDUP));
  1297.         DEBUGMSG(ZONE_INIT, (TEXT("rGPDDAT: 0x%Xrn"), pHWHead->pIrqCtrlAddr->rGPDDAT));
  1298. }
  1299. else if (pHWHead->State == OFF) 
  1300. {
  1301. DEBUGMSG(1, (TEXT("HW_USBClocks::OFFrn")));
  1302.         //
  1303.         // Disable the USB Clocks
  1304.         //
  1305.         pHWHead->pCLKPWR->rCLKCON &= ~(1<<7);
  1307.         DEBUGMSG(ZONE_INIT, (TEXT("rCLKCON: 0x%Xrn"), pHWHead->pCLKPWR->rCLKCON));
  1308.         
  1309.         // Fin=12MHz, Fout=48MHz
  1310.         //pHWHead->pCLKPWR->rUPLLCON = 0;
  1311.         // MISCCR: USBD Pads, Suspend mode
  1312.         pHWHead->pIrqCtrlAddr->rMISCCR |= (3 << 12);
  1314.         // TO DO :
  1315.         // Disable USB_PULLUP to remove us from the bus
  1316.         
  1318.         //pHWHead->pIrqCtrlAddr->rGPBCON &= ~(3 << 18);    // clear GPE15
  1319.         //pHWHead->pIrqCtrlAddr->rGPBCON |=  (1 << 18);    // config as output
  1320.         //pHWHead->pIrqCtrlAddr->rGPBUP  |=  (1 << 9);    // pullup disabled
  1321.         //pHWHead->pIrqCtrlAddr->rGPBDAT &= ~(1 << 9);    // set low
  1322.         
  1323. pHWHead->pIrqCtrlAddr->rGPGCON &= ~(3 << 24);    // clear GPE15
  1324.         pHWHead->pIrqCtrlAddr->rGPGCON |=  (1 << 24);    // config as output
  1325.         pHWHead->pIrqCtrlAddr->rGPGUP  |=  (1 << 12);    // pullup disabled
  1326.         pHWHead->pIrqCtrlAddr->rGPGDAT &= ~(1 << 12);    // set low
  1328. DEBUGMSG(ZONE_INIT, (TEXT("rUPLLCON: 0x%Xrn"), pHWHead->pCLKPWR->rUPLLCON));
  1329. }
  1330. }
  1333. // :-)
  1334. /***************************************
  1335.   Added routines for USBD Rx:DMA Tx:ISR
  1336.  ***************************************/
  1338. BOOL InitUsbdDriverGlobals(void)
  1339. {
  1340. BOOL Ret;
  1341. int i;
  1343. if ( v_pDriverGlobals == NULL )
  1344. {
  1345. v_pDriverGlobals =(PDRIVER_GLOBALS)VirtualAlloc( 0,
  1346. DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,
  1347. MEM_RESERVE,
  1348. PAGE_NOACCESS);
  1349. if ( v_pDriverGlobals == NULL )
  1350. {
  1351.     USBDMSG( 1, (TEXT( "InitUsbdDriverGlobals : VirtualAlloc failed!rn")) );
  1352. return ( FALSE );
  1353. }
  1355. Ret = VirtualCopy( (LPVOID)v_pDriverGlobals,
  1356.    (LPVOID)DRIVER_GLOBALS_PHYSICAL_MEMORY_START,
  1357.    DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,
  1358.    PAGE_READWRITE | PAGE_NOCACHE
  1359.    );
  1361. if ( Ret == FALSE )
  1362. {
  1363. DEBUGMSG( ZONE_ERROR, (TEXT( "InitUsbdDriverGlobals: VirtualCopy failed!rn")) );
  1364. if ( v_pDriverGlobals )
  1365. {
  1366. VirtualFree( v_pDriverGlobals,
  1367.  DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE ,
  1368.  MEM_RELEASE
  1369. );
  1370. v_pDriverGlobals = NULL;
  1371. } 
  1372. return ( FALSE );
  1373. }
  1374. }
  1376. usbdShMem=&(v_pDriverGlobals->usbd);
  1378.     for(i=0;i<USBD_GLOBALS_BUF_SIZE;i++)
  1379.     {
  1380.         usbdShMem->usbdRxBuf[i]=0x0;
  1381. //usbdShMem->usbdTxBuf[i]=0x0;
  1382.     }
  1383. usbdShMem->usbdRxRdPt=0;
  1384. usbdShMem->usbdRxWrPt=0;
  1385. usbdShMem->usbdRxCnt=0;
  1386. //usbdShMem->usbdTxRdPt=0;
  1387. //usbdShMem->usbdTxWrPt=0;
  1388. //usbdShMem->usbdTxCnt=0;
  1389. usbdShMem->usbdEir=0;
  1390.   usbdShMem->usbdUir=0;
  1391. usbdShMem->usbdDma3Int=0; 
  1392. //usbdShMem->usbdMddRxCnt=0;
  1393. USBDMSG( 1, (TEXT( "USBD:DRIVER_GLOBALS is initializedrn")) );
  1394. return( TRUE ); 
  1395. }
  1399. BOOL UsbdAllocateVm(void)
  1400. {
  1401. if(v_pDMAregs == NULL) 
  1402. {
  1403. v_pDMAregs = (volatile DMAreg *) 
  1404. VirtualAlloc(0,sizeof(DMAreg),MEM_RESERVE, PAGE_NOACCESS);
  1405. if(v_pDMAregs == NULL)
  1406. {
  1407. ERRORMSG(1,(TEXT("For DMAreg: VirtualAlloc failed!rn")));
  1408. return (FALSE);
  1409. }
  1410. else 
  1411. {
  1412. if(!VirtualCopy((PVOID)v_pDMAregs,(PVOID)(DMA_BASE),sizeof(DMAreg),
  1413. PAGE_READWRITE | PAGE_NOCACHE )) 
  1414. {
  1415. ERRORMSG(1,(TEXT("For pIOPregs: VirtualCopy failed!rn")));
  1416. UsbdDeallocateVm();
  1417. return (FALSE);
  1418. }
  1419. }
  1420. }
  1422. if(v_pINTregs == NULL)
  1423. {
  1424.      v_pINTregs = (volatile INTreg *) 
  1425.      VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
  1426.     if(v_pINTregs == NULL)
  1427. {
  1428.     ERRORMSG(1,(TEXT("For INTreg: VirtualAlloc failed!rn")));
  1429. return (FALSE);
  1430.     }
  1431.      else 
  1432. {
  1433.      if(!VirtualCopy((PVOID)v_pINTregs,(PVOID)(INT_BASE),sizeof(INTreg),
  1434.         PAGE_READWRITE | PAGE_NOCACHE ))
  1435.     {
  1436. ERRORMSG(1,(TEXT("For INTreg: VirtualCopy failed!rn")));
  1437.      return (FALSE);
  1438.      }
  1439.     }
  1440. }
  1442. return TRUE;
  1443. }
  1447. void UsbdDeallocateVm(void)
  1448. {
  1449. if(v_pDMAregs)
  1450. {
  1451. VirtualFree((void*)v_pDMAregs, sizeof(DMAreg), MEM_RELEASE);
  1452. v_pDMAregs=NULL;
  1453. }
  1455. if(v_pINTregs)
  1456. {
  1457. VirtualFree((void*)v_pINTregs, sizeof(INTreg), MEM_RELEASE);
  1458. v_pINTregs=NULL;
  1459. }
  1460. }
  1464. void UsbdInitDma3(int bufIndex,int bufOffset)
  1465. {
  1466. //ULONG usbdRxRdPt,usbdRxWrPt;
  1468.    //If DMA3 is turned on, DMA3 should be turned off.
  1469. if((v_pDMAregs->rDMASKTRIG3&(1<<1))!=0)
  1470. {
  1471. v_pDMAregs->rDMASKTRIG3=(1<<2); //DMA3 stop
  1472. while(v_pDMAregs->rDMASKTRIG3&(1<<1)); //wait until DMA3 stop
  1473. usbdShMem->usbdRxRdPt=0;
  1474. USBDMSG( 1, (TEXT("[DMA3 is stopped]rn")));
  1475. }
  1477. v_pDMAregs->rDISRCC3 = (1<<1)|(1<<0);    //src=APB, srcAddr=fixed
  1478. v_pDMAregs->rDISRC3 = REAL_PHYSICAL_ADDR_EP4_FIFO; //srcAddr=EP4_FIFO 
  1479. v_pDMAregs->rDIDSTC3 = (0<<1)|(0<<0);    //dst=AHB(memory),increase,
  1481. #if (DRIVER_GLOBALS_PHYSICAL_MEMORY_START<0xA0000000 || DMA_BUFFER_BASE<0xA0000000) 
  1482. GENERATE_ERROR
  1483.     //The above two address should be non-cacheable area.
  1484. #endif  
  1486. realPhysicalAddr_UsbdRxBuf = 
  1487. (ULONG)&((DRIVER_GLOBALS *)DRIVER_GLOBALS_PHYSICAL_MEMORY_START)->usbd.usbdRxBuf 
  1488. - DMA_BUFFER_BASE + DMA_PHYSICAL_BASE;
  1489. //USBDMSG( 1, (TEXT( "[USBD:RPA_URxBuf=%x]"),realPhysicalAddr_UsbdRxBuf) );
  1490. //Real physical address of usbdShMem->usbdRxBuf
  1492. if(bufIndex==0)
  1493. {
  1494.     v_pDMAregs->rDIDST3=realPhysicalAddr_UsbdRxBuf+0+bufOffset;
  1495. }
  1496. else
  1497. {
  1498. v_pDMAregs->rDIDST3=realPhysicalAddr_UsbdRxBuf+(USBD_GLOBALS_BUF_SIZE/2)+bufOffset;
  1499. }
  1501.     v_pDMAregs->rDCON3=(USBD_GLOBALS_BUF_SIZE-bufOffset)|(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(4<<24)|(1<<23)|(1<<22)|(0<<20); 
  1502. //handshake,requestor=APB,CURR_TC int enable,unit transfer,
  1503. //single service,src=USBD,H/W request,no_autoreload,byte,CURR_TC
  1505. v_pDMAregs->rDMASKTRIG3=(1<<1); //DMA 3 on
  1506.    
  1508. USBDMSG( 1, (TEXT( "[USBD:rDIDST3=%x,rDCDST3=%x]rn"),v_pDMAregs->rDIDST3,v_pDMAregs->rDCDST3) );
  1510. }