Maxim Integrated
USB device stack
Dependents: blinky_max32630fthr FTHR_USB_serial FTHR_OLED HSP_RPC_GUI_3_0_1 ... more
Fork of
USBDevice
by 
mbed official
Embed:
(wiki syntax)
Show/hide line numbers
USBHAL_RZ_A1H.cpp
00001 /* Copyright (c) 2010-2011 mbed.org, MIT License 00002 * 00003 * Permission is hereby granted, free of charge, to any person 00004 * obtaining a copy of this software and associated documentation 00005 * files (the "Software"), to deal in the Software without 00006 * restriction, including without limitation the rights to use, 00007 * copy, modify, merge, publish, distribute, sublicense, and/or 00008 * sell copies of the Software, and to permit persons to whom the 00009 * Software is furnished to do so, subject to the following 00010 * conditions: 00011 * 00012 * The above copyright notice and this permission notice shall be 00013 * included in all copies or substantial portions of the 00014 * Software. 00015 * 00016 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY 00017 * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 00018 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 00019 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 00020 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00021 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 00022 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 00023 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 00024 */ 00025 00026 #if defined(TARGET_RZ_A1H) || defined(TARGET_VK_RZ_A1H) 00027 00028 /* 00029 This class can use the pipe1, pipe3 and pipe6 only. You should 00030 re-program this class if you wanted to use other pipe. 00031 */ 00032 00033 /*************************************************************************/ 00034 extern "C" 00035 { 00036 #include "r_typedefs.h" 00037 #include "iodefine.h" 00038 } 00039 #include "USBHAL.h" 00040 #include "devdrv_usb_function_api.h" 00041 #include "usb_iobitmask.h" 00042 #include "rza_io_regrw.h" 00043 #include "USBDevice_Types.h" 00044 #include "usb_function_setting.h" 00045 00046 00047 /*************************************************************************/ 00048 /* constants */ 00049 const struct PIPECFGREC { 00050 uint16_t endpoint; 00051 uint16_t pipesel; 00052 uint16_t pipecfg; 00053 uint16_t pipebuf; 00054 uint16_t pipemaxp; 00055 uint16_t pipeperi; 00056 } def_pipecfg[] = { 00057 /*EP0OUT and EP0IN are configured by USB IP*/ 00058 { 00059 EP1OUT, /*EP1: Host -> Func, INT*/ 00060 6 | USB_FUNCTION_D0FIFO_USE, 00061 USB_FUNCTION_INTERRUPT | 00062 USB_FUNCTION_BFREOFF | 00063 USB_FUNCTION_DBLBOFF | 00064 USB_FUNCTION_CNTMDON | 00065 USB_FUNCTION_SHTNAKOFF | 00066 USB_FUNCTION_DIR_P_OUT | 00067 USB_FUNCTION_EP1, 00068 ( ( ( 64) / 64 - 1 ) << 10 ) | 0x04u, 00069 MAX_PACKET_SIZE_EP1, 00070 DEVDRV_USBF_OFF | 00071 ( 3 << USB_PIPEPERI_IITV_SHIFT ), 00072 }, 00073 { 00074 EP1IN, /*EP1: Host <- Func, INT*/ 00075 7 | USB_FUNCTION_D1FIFO_USE, 00076 USB_FUNCTION_INTERRUPT | 00077 USB_FUNCTION_BFREOFF | 00078 USB_FUNCTION_DBLBOFF | 00079 USB_FUNCTION_CNTMDOFF | 00080 USB_FUNCTION_SHTNAKOFF | 00081 USB_FUNCTION_DIR_P_IN | 00082 USB_FUNCTION_EP1, 00083 ( ( ( 64) / 64 - 1 ) << 10 ) | 0x05u, 00084 MAX_PACKET_SIZE_EP1, 00085 DEVDRV_USBF_OFF | 00086 ( 3 << USB_PIPEPERI_IITV_SHIFT ), 00087 }, 00088 { 00089 EP2OUT, /*EP2: Host -> Func, BULK*/ 00090 3 | USB_FUNCTION_D0FIFO_USE, 00091 USB_FUNCTION_BULK | 00092 USB_FUNCTION_BFREOFF | 00093 USB_FUNCTION_DBLBON | 00094 USB_FUNCTION_CNTMDON | 00095 USB_FUNCTION_SHTNAKON | 00096 USB_FUNCTION_DIR_P_OUT | 00097 USB_FUNCTION_EP2, 00098 ( ( (2048) / 64 - 1 ) << 10 ) | 0x30u, 00099 MAX_PACKET_SIZE_EP2, 00100 DEVDRV_USBF_OFF | 00101 ( 0 << USB_PIPEPERI_IITV_SHIFT ), 00102 }, 00103 { 00104 EP2IN, /*EP2: Host <- Func, BULK*/ 00105 4 | USB_FUNCTION_D1FIFO_USE, 00106 USB_FUNCTION_BULK | 00107 USB_FUNCTION_BFREOFF | 00108 USB_FUNCTION_DBLBOFF | 00109 USB_FUNCTION_CNTMDON | 00110 USB_FUNCTION_SHTNAKOFF | 00111 USB_FUNCTION_DIR_P_IN | 00112 USB_FUNCTION_EP2, 00113 ( ( (2048) / 64 - 1 ) << 10 ) | 0x50u, 00114 MAX_PACKET_SIZE_EP2, 00115 DEVDRV_USBF_OFF | 00116 ( 0 << USB_PIPEPERI_IITV_SHIFT ), 00117 }, 00118 { 00119 EP3OUT, /*EP3: Host -> Func, ISO*/ 00120 1 | USB_FUNCTION_D0FIFO_USE, 00121 USB_FUNCTION_ISO | 00122 USB_FUNCTION_BFREOFF | 00123 USB_FUNCTION_DBLBON | 00124 USB_FUNCTION_CNTMDOFF | 00125 USB_FUNCTION_SHTNAKON | 00126 USB_FUNCTION_DIR_P_OUT | 00127 USB_FUNCTION_EP3, 00128 ( ( ( 512) / 64 - 1 ) << 10 ) | 0x10u, 00129 MAX_PACKET_SIZE_EP3, 00130 DEVDRV_USBF_OFF | 00131 ( 0 << USB_PIPEPERI_IITV_SHIFT ), 00132 }, 00133 { 00134 EP3IN, /*EP3: Host <- Func, ISO*/ 00135 2 | USB_FUNCTION_D1FIFO_USE, 00136 USB_FUNCTION_ISO | 00137 USB_FUNCTION_BFREOFF | 00138 USB_FUNCTION_DBLBON | 00139 USB_FUNCTION_CNTMDOFF | 00140 USB_FUNCTION_SHTNAKOFF | 00141 USB_FUNCTION_DIR_P_IN | 00142 USB_FUNCTION_EP3, 00143 ( ( ( 512) / 64 - 1 ) << 10 ) | 0x20u, 00144 MAX_PACKET_SIZE_EP3, 00145 DEVDRV_USBF_OFF | 00146 ( 0 << USB_PIPEPERI_IITV_SHIFT ), 00147 }, 00148 { /*terminator*/ 00149 0, 0, 0, 0, 0, 00150 }, 00151 }; 00152 00153 00154 /*************************************************************************/ 00155 /* workareas */ 00156 USBHAL * USBHAL::instance; 00157 00158 static IRQn_Type int_id; /* interrupt ID */ 00159 static uint16_t int_level; /* initerrupt level */ 00160 static uint16_t clock_mode; /* input clock selector */ 00161 static uint16_t mode; /* USB speed (HIGH/FULL) */ 00162 00163 //static DigitalOut *usbx_en; 00164 00165 static uint16_t EP0_read_status; 00166 static uint16_t EPx_read_status; 00167 00168 static uint16_t setup_buffer[MAX_PACKET_SIZE_EP0 / 2]; 00169 00170 /* 0: not used / other: a pipe number to use recv_buffer*/ 00171 static uint8_t recv_buffer[MAX_PACKET_SIZE_EPBULK]; 00172 volatile static uint16_t recv_error; 00173 00174 00175 /*************************************************************************/ 00176 /* prototypes for C */ 00177 extern "C" { 00178 void usbx_function_BRDYInterruptPIPE0 (uint16_t status, uint16_t intenb, 00179 USBHAL *object, void (USBHAL::*EP0func)(void)); 00180 00181 void usbx_function_BRDYInterrupt (uint16_t status, uint16_t intenb, 00182 USBHAL *object, bool (USBHAL::*epCallback[])(void)); 00183 00184 void usbx_function_NRDYInterruptPIPE0(uint16_t status, uint16_t intenb, 00185 USBHAL *object, void (USBHAL::*EP0func)(void)); 00186 00187 void usbx_function_NRDYInterrupt (uint16_t status, uint16_t intenb, 00188 USBHAL *object, bool (USBHAL::*epCallback[])(void)); 00189 00190 void usbx_function_BEMPInterruptPIPE0(uint16_t status, uint16_t intenb, 00191 USBHAL *object, void (USBHAL::*EP0func)(void)); 00192 00193 void usbx_function_BEMPInterrupt (uint16_t status, uint16_t intenb, 00194 USBHAL *object, bool (USBHAL::*epCallback[])(void)); 00195 } 00196 00197 00198 /*************************************************************************/ 00199 /* macros */ 00200 00201 /****************************************************************************** 00202 * Function Name: usbx_function_BRDYInterruptPIPE0 00203 * Description : Executes BRDY interrupt for pipe0. 00204 * Arguments : uint16_t status ; BRDYSTS Register Value 00205 * : uint16_t intenb ; BRDYENB Register Value 00206 * Return Value : none 00207 *****************************************************************************/ 00208 extern "C" { 00209 void usbx_function_BRDYInterruptPIPE0 ( 00210 uint16_t status, 00211 uint16_t intenb, 00212 USBHAL *object, 00213 void (USBHAL::*EP0func)(void) 00214 ) 00215 { 00216 volatile uint16_t dumy_sts; 00217 uint16_t read_status; 00218 00219 USB20X.BRDYSTS = 00220 (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0]; 00221 RZA_IO_RegWrite_16( 00222 &USB20X.CFIFOSEL, USB_FUNCTION_PIPE0, 00223 USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE); 00224 00225 g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0] = 00226 g_usbx_function_data_count[USB_FUNCTION_PIPE0]; 00227 00228 read_status = usbx_function_read_buffer_c(USB_FUNCTION_PIPE0); 00229 00230 g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0] -= 00231 g_usbx_function_data_count[USB_FUNCTION_PIPE0]; 00232 00233 switch (read_status) { 00234 case USB_FUNCTION_READING: /* Continue of data read */ 00235 case USB_FUNCTION_READEND: /* End of data read */ 00236 /* PID = BUF */ 00237 usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); 00238 00239 /*callback*/ 00240 (object->*EP0func)(); 00241 break; 00242 00243 case USB_FUNCTION_READSHRT: /* End of data read */ 00244 usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0); 00245 /* PID = BUF */ 00246 usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); 00247 00248 /*callback*/ 00249 (object->*EP0func)(); 00250 break; 00251 00252 case USB_FUNCTION_READOVER: /* FIFO access error */ 00253 /* Buffer Clear */ 00254 USB20X.CFIFOCTR = USB_FUNCTION_BITBCLR; 00255 usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0); 00256 /* Req Error */ 00257 usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); 00258 00259 /*callback*/ 00260 (object->*EP0func)(); 00261 break; 00262 00263 case DEVDRV_USBF_FIFOERROR: /* FIFO access error */ 00264 default: 00265 usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0); 00266 /* Req Error */ 00267 usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); 00268 break; 00269 } 00270 /* Three dummy reads for clearing interrupt requests */ 00271 dumy_sts = USB20X.BRDYSTS; 00272 } 00273 } 00274 00275 00276 /****************************************************************************** 00277 * Function Name: usbx_function_BRDYInterrupt 00278 * Description : Executes BRDY interrupt uxclude pipe0. 00279 * Arguments : uint16_t status ; BRDYSTS Register Value 00280 * : uint16_t intenb ; BRDYENB Register Value 00281 * Return Value : none 00282 *****************************************************************************/ 00283 extern "C" { 00284 void usbx_function_BRDYInterrupt( 00285 uint16_t status, 00286 uint16_t intenb, 00287 USBHAL *object, 00288 bool (USBHAL::*epCallback[])(void) 00289 ) 00290 { 00291 volatile uint16_t dumy_sts; 00292 00293 /************************************************************** 00294 * Function Name: usbx_function_brdy_int 00295 * Description : Executes BRDY interrupt(USB_FUNCTION_PIPE1-9). 00296 * : According to the pipe that interrupt is generated in, 00297 * : reads/writes buffer allocated in the pipe. 00298 * : This function is executed in the BRDY 00299 * : interrupt handler. This function 00300 * : clears BRDY interrupt status and BEMP 00301 * : interrupt status. 00302 * Arguments : uint16_t Status ; BRDYSTS Register Value 00303 * : uint16_t Int_enbl ; BRDYENB Register Value 00304 * Return Value : none 00305 *************************************************************/ 00306 /* copied from usbx_function_intrn.c */ 00307 uint32_t int_sense = 0; 00308 uint16_t pipe; 00309 uint16_t pipebit; 00310 uint16_t ep; 00311 00312 for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) { 00313 pipebit = g_usbx_function_bit_set[pipe]; 00314 00315 if ((status & pipebit) && (intenb & pipebit)) { 00316 USB20X.BRDYSTS = (uint16_t)~pipebit; 00317 USB20X.BEMPSTS = (uint16_t)~pipebit; 00318 00319 switch (g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) { 00320 case USB_FUNCTION_D0FIFO_DMA: 00321 if (g_usbx_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY) { 00322 /*now, DMA is not supported*/ 00323 usbx_function_dma_interrupt_d0fifo(int_sense); 00324 } 00325 00326 if (RZA_IO_RegRead_16( 00327 &g_usbx_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) { 00328 /*now, DMA is not supported*/ 00329 usbx_function_read_dma(pipe); 00330 usbx_function_disable_brdy_int(pipe); 00331 } else { 00332 USB20X.D0FIFOCTR = USB_FUNCTION_BITBCLR; 00333 g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; 00334 } 00335 break; 00336 00337 case USB_FUNCTION_D1FIFO_DMA: 00338 if (g_usbx_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY) { 00339 /*now, DMA is not supported*/ 00340 usbx_function_dma_interrupt_d1fifo(int_sense); 00341 } 00342 00343 if (RZA_IO_RegRead_16( 00344 &g_usbx_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) { 00345 /*now, DMA is not supported*/ 00346 usbx_function_read_dma(pipe); 00347 usbx_function_disable_brdy_int(pipe); 00348 } else { 00349 USB20X.D1FIFOCTR = USB_FUNCTION_BITBCLR; 00350 g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; 00351 } 00352 break; 00353 00354 default: 00355 ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; 00356 ep <<= 1; 00357 if (RZA_IO_RegRead_16( 00358 &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) { 00359 /* read */ 00360 EPx_read_status = DEVDRV_USBF_PIPE_WAIT; 00361 (object->*(epCallback[ep - 2])) (); 00362 EPx_read_status = DEVDRV_USBF_PIPE_DONE; 00363 } else { 00364 /* write */ 00365 EPx_read_status = DEVDRV_USBF_PIPE_WAIT; 00366 (object->*(epCallback[ep - 2 + 1])) (); 00367 EPx_read_status = DEVDRV_USBF_PIPE_DONE; 00368 usbx_function_write_buffer(pipe); 00369 } 00370 } 00371 } 00372 } 00373 /* Three dummy reads for clearing interrupt requests */ 00374 dumy_sts = USB20X.BRDYSTS; 00375 } 00376 } 00377 00378 00379 /****************************************************************************** 00380 * Function Name: usbx_function_NRDYInterruptPIPE0 00381 * Description : Executes NRDY interrupt for pipe0. 00382 * Arguments : uint16_t status ; NRDYSTS Register Value 00383 * : uint16_t intenb ; NRDYENB Register Value 00384 * Return Value : none 00385 *****************************************************************************/ 00386 extern "C" { 00387 void usbx_function_NRDYInterruptPIPE0( 00388 uint16_t status, 00389 uint16_t intenb, 00390 USBHAL *object, 00391 void (USBHAL::*EP0func)(void) 00392 ) 00393 { 00394 volatile uint16_t dumy_sts; 00395 00396 USB20X.NRDYSTS = 00397 (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0]; 00398 00399 /* Three dummy reads for clearing interrupt requests */ 00400 dumy_sts = USB20X.NRDYSTS; 00401 } 00402 } 00403 00404 00405 /****************************************************************************** 00406 * Function Name: usbx_function_NRDYInterrupt 00407 * Description : Executes NRDY interrupt exclude pipe0. 00408 * Arguments : uint16_t status ; NRDYSTS Register Value 00409 * : uint16_t intenb ; NRDYENB Register Value 00410 * Return Value : none 00411 *****************************************************************************/ 00412 extern "C" { 00413 void usbx_function_NRDYInterrupt( 00414 uint16_t status, 00415 uint16_t intenb, 00416 USBHAL *object, 00417 bool (USBHAL::*epCallback[])(void) 00418 ) 00419 { 00420 volatile uint16_t dumy_sts; 00421 00422 /************************************************************** 00423 * Function Name: usbx_function_nrdy_int 00424 * Description : Executes NRDY interrupt(USB_FUNCTION_PIPE1-9). 00425 * : Checks NRDY interrupt cause by PID. When the cause if STALL, 00426 * : regards the pipe state as STALL and ends the processing. 00427 * : Then the cause is not STALL, increments the error count to 00428 * : communicate again. When the error count is 3, determines 00429 * : the pipe state as DEVDRV_USBF_PIPE_NORES and ends the processing. 00430 * : This function is executed in the NRDY interrupt handler. 00431 * : This function clears NRDY interrupt status. 00432 * Arguments : uint16_t status ; NRDYSTS Register Value 00433 * : uint16_t int_enb ; NRDYENB Register Value 00434 * Return Value : none 00435 *************************************************************/ 00436 /* copied from usbx_function_intrn.c */ 00437 #if 0 00438 uint16_t usefifo; 00439 #endif 00440 uint16_t pid; 00441 uint16_t pipe; 00442 uint16_t bitcheck; 00443 #if 0 00444 uint16_t mbw; 00445 uint32_t size; 00446 #endif 00447 uint16_t ep; 00448 00449 bitcheck = (uint16_t)(status & intenb); 00450 00451 USB20X.NRDYSTS = (uint16_t)~status; 00452 00453 00454 if (RZA_IO_RegRead_16(&USB20X.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1) { 00455 /* USB HOST */ 00456 /* not support */ 00457 00458 } else { 00459 /* USB Function */ 00460 for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) { 00461 if ((bitcheck&g_usbx_function_bit_set[pipe]) != g_usbx_function_bit_set[pipe]) { 00462 continue; 00463 } 00464 00465 if (g_usbx_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_WAIT) { 00466 continue; 00467 } 00468 00469 #if 0 00470 usbx_function_set_pid_nak(pipe); 00471 00472 size = (uint32_t)g_usbx_function_data_count[pipe]; 00473 mbw = usbx_function_get_mbw( 00474 size, (uint32_t)g_usbx_function_data_pointer[pipe]); 00475 00476 usefifo = (uint16_t)(g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); 00477 switch (usefifo) { 00478 00479 case USB_FUNCTION_D0FIFO_USE: 00480 usbx_function_set_curpipe( 00481 pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); 00482 USB20X.D0FIFOCTR = USB_FUNCTION_BITBCLR; 00483 break; 00484 00485 case USB_FUNCTION_D1FIFO_USE: 00486 usbx_function_set_curpipe( 00487 pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); 00488 USB20X.D1FIFOCTR = USB_FUNCTION_BITBCLR; 00489 break; 00490 00491 default: 00492 usbx_function_set_curpipe( 00493 pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw); 00494 USB20X.CFIFOCTR = USB_FUNCTION_BITBCLR; 00495 break; 00496 } 00497 00498 usbx_function_aclrm(pipe); 00499 00500 usbx_function_enable_nrdy_int(pipe); 00501 usbx_function_enable_brdy_int(pipe); 00502 00503 usbx_function_set_pid_buf(pipe); 00504 #endif 00505 00506 pid = usbx_function_get_pid(pipe); 00507 if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) { 00508 g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; 00509 } else { 00510 usbx_function_set_pid_buf(pipe); 00511 } 00512 00513 ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; 00514 ep <<= 1; 00515 if (RZA_IO_RegRead_16( 00516 &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) { 00517 /* read */ 00518 __NOP(); 00519 } else { 00520 /* write */ 00521 __NOP(); 00522 } 00523 } 00524 } 00525 00526 /* Three dummy reads for clearing interrupt requests */ 00527 dumy_sts = USB20X.NRDYSTS; 00528 } 00529 } 00530 00531 /****************************************************************************** 00532 * Function Name: usbx_function_BEMPInterruptPIPE0 00533 * Description : Executes BEMP interrupt for pipe0. 00534 * Arguments : uint16_t status ; BEMPSTS Register Value 00535 * : uint16_t intenb ; BEMPENB Register Value 00536 * Return Value : none 00537 *****************************************************************************/ 00538 extern "C" { 00539 void usbx_function_BEMPInterruptPIPE0( 00540 uint16_t status, 00541 uint16_t intenb, 00542 USBHAL *object, 00543 void (USBHAL::*EP0func)(void) 00544 ) 00545 { 00546 volatile uint16_t dumy_sts; 00547 00548 USB20X.BEMPSTS = 00549 (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0]; 00550 RZA_IO_RegWrite_16( 00551 &USB20X.CFIFOSEL, USB_FUNCTION_PIPE0, 00552 USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE); 00553 00554 /*usbx_function_write_buffer_c(USB_FUNCTION_PIPE0);*/ 00555 (object->*EP0func)(); 00556 00557 /* Three dummy reads for clearing interrupt requests */ 00558 dumy_sts = USB20X.BEMPSTS; 00559 } 00560 } 00561 00562 00563 /****************************************************************************** 00564 * Function Name: usbx_function_BEMPInterrupt 00565 * Description : Executes BEMP interrupt exclude pipe0. 00566 * Arguments : uint16_t status ; BEMPSTS Register Value 00567 * : uint16_t intenb ; BEMPENB Register Value 00568 * Return Value : none 00569 *****************************************************************************/ 00570 extern "C" { 00571 void usbx_function_BEMPInterrupt( 00572 uint16_t status, 00573 uint16_t intenb, 00574 USBHAL *object, 00575 bool (USBHAL::*epCallback[])(void) 00576 ) 00577 { 00578 volatile uint16_t dumy_sts; 00579 00580 /************************************************************** 00581 * Function Name: usbx_function_bemp_int 00582 * Description : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9). 00583 * Arguments : uint16_t status ; BEMPSTS Register Value 00584 * : uint16_t intenb ; BEMPENB Register Value 00585 * Return Value : none 00586 *************************************************************/ 00587 /* copied from usbx_function_intrn.c */ 00588 uint16_t pid; 00589 uint16_t pipe; 00590 uint16_t bitcheck; 00591 uint16_t inbuf; 00592 uint16_t ep; 00593 00594 bitcheck = (uint16_t)(status & intenb); 00595 00596 USB20X.BEMPSTS = (uint16_t)~status; 00597 00598 for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) { 00599 if ((bitcheck&g_usbx_function_bit_set[pipe]) != g_usbx_function_bit_set[pipe]) { 00600 continue; 00601 } 00602 00603 pid = usbx_function_get_pid(pipe); 00604 00605 if ((pid == DEVDRV_USBF_PID_STALL) || 00606 (pid == DEVDRV_USBF_PID_STALL2)) { 00607 g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; 00608 00609 } else { 00610 inbuf = usbx_function_get_inbuf(pipe); 00611 00612 if (inbuf == 0) { 00613 usbx_function_disable_bemp_int(pipe); 00614 usbx_function_set_pid_nak(pipe); 00615 g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; 00616 00617 switch (g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) { 00618 case USB_FUNCTION_D0FIFO_DMA: 00619 /*now, DMA is not supported*/ 00620 break; 00621 00622 case USB_FUNCTION_D1FIFO_DMA: 00623 /*now, DMA is not supported*/ 00624 break; 00625 00626 default: 00627 ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; 00628 ep <<= 1; 00629 if (RZA_IO_RegRead_16( 00630 &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) { 00631 /* read */ 00632 __NOP(); 00633 } else { 00634 /* write */ 00635 EPx_read_status = DEVDRV_USBF_PIPE_WAIT; 00636 (object->*(epCallback[ep - 2 + 1])) (); 00637 EPx_read_status = DEVDRV_USBF_PIPE_DONE; 00638 } 00639 } 00640 } 00641 } 00642 } 00643 00644 /* Three dummy reads for clearing interrupt requests */ 00645 dumy_sts = USB20X.BEMPSTS; 00646 } 00647 } 00648 00649 /****************************************************************************** 00650 * Function Name: EP2PIPE 00651 * Description : Converts from endpoint to pipe 00652 * Arguments : number of endpoint 00653 * Return Value : number of pipe 00654 *****************************************************************************/ 00655 /*EP2PIPE converter is for pipe1, pipe3 and pipe6 only.*/ 00656 #define EP2PIPE(endpoint) ((uint32_t)usbx_function_EpToPipe(endpoint)) 00657 00658 00659 /****************************************************************************** 00660 * Function Name: usbx_function_save_request 00661 * Description : Retains the USB request information in variables. 00662 * Arguments : none 00663 * Return Value : none 00664 *****************************************************************************/ 00665 #define usbx_function_save_request() \ 00666 { \ 00667 uint16_t *bufO = &setup_buffer[0]; \ 00668 \ 00669 USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVALID; \ 00670 /*data[0] <= bmRequest, data[1] <= bmRequestType */ \ 00671 *bufO++ = USB20X.USBREQ; \ 00672 /*data[2] data[3] <= wValue*/ \ 00673 *bufO++ = USB20X.USBVAL; \ 00674 /*data[4] data[5] <= wIndex*/ \ 00675 *bufO++ = USB20X.USBINDX; \ 00676 /*data[6] data[6] <= wIndex*/ \ 00677 *bufO++ = USB20X.USBLENG; \ 00678 } 00679 00680 00681 /*************************************************************************/ 00682 /*************************************************************************/ 00683 /*************************************************************************/ 00684 00685 /*************************************************************************/ 00686 /* constructor */ 00687 USBHAL::USBHAL(void) 00688 { 00689 /* ---- P4_1 : P4_1 (USB0_EN for GR-PEACH) ---- */ 00690 //usbx_en = new DigitalOut(P4_1, 1); 00691 00692 /* some constants */ 00693 int_id = USBIX_IRQn; 00694 int_level = ( 2 << 3 ); 00695 clock_mode = USBFCLOCK_X1_48MHZ; 00696 #if (USB_FUNCTION_HISPEED == 0) 00697 mode = USB_FUNCTION_FULL_SPEED; 00698 #else 00699 mode = USB_FUNCTION_HIGH_SPEED; 00700 #endif 00701 EP0_read_status = DEVDRV_USBF_WRITEEND; 00702 EPx_read_status = DEVDRV_USBF_PIPE_DONE; 00703 00704 /* Disables interrupt for usb */ 00705 GIC_DisableIRQ(int_id); 00706 00707 /* Setup the end point */ 00708 epCallback[ 0] = &USBHAL::EP1_OUT_callback; 00709 epCallback[ 1] = &USBHAL::EP1_IN_callback; 00710 epCallback[ 2] = &USBHAL::EP2_OUT_callback; 00711 epCallback[ 3] = &USBHAL::EP2_IN_callback; 00712 epCallback[ 4] = &USBHAL::EP3_OUT_callback; 00713 epCallback[ 5] = &USBHAL::EP3_IN_callback; 00714 epCallback[ 6] = &USBHAL::EP4_OUT_callback; 00715 epCallback[ 7] = &USBHAL::EP4_IN_callback; 00716 epCallback[ 8] = &USBHAL::EP5_OUT_callback; 00717 epCallback[ 9] = &USBHAL::EP5_IN_callback; 00718 epCallback[10] = &USBHAL::EP6_OUT_callback; 00719 epCallback[11] = &USBHAL::EP6_IN_callback; 00720 epCallback[12] = &USBHAL::EP7_OUT_callback; 00721 epCallback[13] = &USBHAL::EP7_IN_callback; 00722 epCallback[14] = &USBHAL::EP8_OUT_callback; 00723 epCallback[15] = &USBHAL::EP8_IN_callback; 00724 epCallback[16] = &USBHAL::EP9_OUT_callback; 00725 epCallback[17] = &USBHAL::EP9_IN_callback; 00726 epCallback[18] = &USBHAL::EP10_OUT_callback; 00727 epCallback[19] = &USBHAL::EP10_IN_callback; 00728 epCallback[20] = &USBHAL::EP11_OUT_callback; 00729 epCallback[21] = &USBHAL::EP11_IN_callback; 00730 epCallback[22] = &USBHAL::EP12_OUT_callback; 00731 epCallback[23] = &USBHAL::EP12_IN_callback; 00732 epCallback[24] = &USBHAL::EP13_OUT_callback; 00733 epCallback[25] = &USBHAL::EP13_IN_callback; 00734 epCallback[26] = &USBHAL::EP14_OUT_callback; 00735 epCallback[27] = &USBHAL::EP14_IN_callback; 00736 epCallback[28] = &USBHAL::EP15_OUT_callback; 00737 epCallback[29] = &USBHAL::EP15_IN_callback; 00738 00739 /* registers me */ 00740 instance = this; 00741 00742 /* Clear pipe table */ 00743 usbx_function_clear_pipe_tbl(); 00744 00745 /****************************************************************************** 00746 * Function Name: usbx_api_function_init 00747 * Description : Initializes the USB module in the USB function mode. 00748 *****************************************************************************/ 00749 /* The clock of USB0 modules is permitted */ 00750 #if (USB_FUNCTION_CH == 0) 00751 CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71); 00752 #else 00753 CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71 | CPG_STBCR7_MSTP70); 00754 #endif 00755 volatile uint8_t dummy8; 00756 dummy8 = CPG.STBCR7; 00757 00758 { 00759 /****************************************************************************** 00760 * Function Name: usbx_function_setting_interrupt 00761 * Description : Sets the USB module interrupt level. 00762 *****************************************************************************/ 00763 #if 0 /*DMA is not supported*/ 00764 IRQn_Type d0fifo_dmaintid; 00765 IRQn_Type d1fifo_dmaintid; 00766 #endif 00767 00768 InterruptHandlerRegister(int_id, &_usbisr); 00769 GIC_SetPriority(int_id, int_level); 00770 GIC_EnableIRQ(int_id); 00771 00772 #if 0 /*DMA is not supported*/ 00773 d0fifo_dmaintid = Userdef_USB_usbx_function_d0fifo_dmaintid(); 00774 if (d0fifo_dmaintid != 0xFFFF) { 00775 InterruptHandlerRegister(d0fifo_dmaintid, usbx_function_dma_interrupt_d0fifo); 00776 GIC_SetPriority(d0fifo_dmaintid, int_level); 00777 GIC_EnableIRQ(d0fifo_dmaintid); 00778 } 00779 #endif 00780 00781 #if 0 /*DMA is not supported*/ 00782 d1fifo_dmaintid = Userdef_USB_usbx_function_d1fifo_dmaintid(); 00783 if (d1fifo_dmaintid != 0xFFFF) { 00784 InterruptHandlerRegister(d1fifo_dmaintid, usbx_function_dma_interrupt_d1fifo); 00785 GIC_SetPriority(d1fifo_dmaintid, int_level); 00786 GIC_EnableIRQ(d1fifo_dmaintid); 00787 } 00788 #endif 00789 /*****************************************************************************/ 00790 } 00791 00792 /* reset USB module with setting tranciever and HSE=1 */ 00793 usbx_function_reset_module(clock_mode); 00794 00795 /* clear variables */ 00796 usbx_function_init_status(); 00797 00798 /* select USB Function and Interrupt Enable */ 00799 /* Detect USB Device to attach or detach */ 00800 usbx_function_InitModule(mode); 00801 00802 { 00803 uint16_t buf; 00804 buf = USB20X.INTENB0; 00805 buf |= USB_INTENB0_SOFE; 00806 USB20X.INTENB0 = buf; 00807 } 00808 } 00809 00810 /*************************************************************************/ 00811 USBHAL::~USBHAL(void) 00812 { 00813 /* Disables interrupt for usb */ 00814 GIC_DisableIRQ( int_id ); 00815 /* Unregisters interrupt function and priority */ 00816 InterruptHandlerRegister( int_id, (uint32_t)NULL ); 00817 00818 //usbx_en = NULL; 00819 instance = NULL; 00820 } 00821 00822 /*************************************************************************/ 00823 void USBHAL::connect(void) 00824 { 00825 /* Activates USB0_EN */ 00826 //(*usbx_en) = 0; 00827 } 00828 00829 00830 /*************************************************************************/ 00831 void USBHAL::disconnect(void) 00832 { 00833 /* Deactivates USB0_EN */ 00834 //(*usbx_en) = 1; 00835 } 00836 00837 00838 /*************************************************************************/ 00839 void USBHAL::configureDevice(void) 00840 { 00841 /*The pipes set up in USBHAL::realiseEndpoint*/ 00842 /*usbx_function_clear_alt();*/ /* Alternate setting clear */ 00843 /*usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);*/ 00844 } 00845 00846 00847 /*************************************************************************/ 00848 void USBHAL::unconfigureDevice(void) 00849 { 00850 /* The Interface would be managed by USBDevice */ 00851 /*usbx_function_clear_alt();*/ /* Alternate setting clear */ 00852 /*usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);*/ 00853 } 00854 00855 00856 /*************************************************************************/ 00857 void USBHAL::setAddress(uint8_t address) 00858 { 00859 if (address <= 127) { 00860 usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); /* OK */ 00861 } else { 00862 usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); /* Not Spec */ 00863 } 00864 } 00865 00866 00867 /*************************************************************************/ 00868 bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags) 00869 { 00870 const struct PIPECFGREC *cfg; 00871 uint16_t pipe; 00872 uint16_t buf; 00873 00874 if ( (EP0OUT == endpoint) || (EP0IN == endpoint) ) { 00875 return true; 00876 } 00877 00878 for (cfg = &def_pipecfg[0]; cfg->pipesel != 0; cfg++) { 00879 if (cfg->endpoint == endpoint) { 00880 break; 00881 } 00882 } 00883 if (cfg->pipesel == 0) { 00884 return false; 00885 } 00886 00887 pipe = ((cfg->pipesel & USB_PIPESEL_PIPESEL) >> USB_PIPESEL_PIPESEL_SHIFT); 00888 00889 g_usbx_function_PipeTbl[ pipe ] = (uint16_t)(endpoint | ((cfg->pipesel & USB_FUNCTION_FIFO_USE) << 0)); 00890 00891 /* There are maintenance routine of SHTNAK and BFRE bits 00892 * in original sample program. This sample is not 00893 * programmed. Do maintenance the "def_pipecfg" array if 00894 * you want it. */ 00895 00896 /* Interrupt Disable */ 00897 buf = USB20X.BRDYENB; 00898 buf &= (uint16_t)~g_usbx_function_bit_set[pipe]; 00899 USB20X.BRDYENB = buf; 00900 buf = USB20X.NRDYENB; 00901 buf &= (uint16_t)~g_usbx_function_bit_set[pipe]; 00902 USB20X.NRDYENB = buf; 00903 buf = USB20X.BEMPENB; 00904 buf &= (uint16_t)~g_usbx_function_bit_set[pipe]; 00905 USB20X.BEMPENB = buf; 00906 00907 usbx_function_set_pid_nak(pipe); 00908 00909 /* CurrentPIPE Clear */ 00910 if (RZA_IO_RegRead_16(&USB20X.CFIFOSEL, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE) == pipe) { 00911 RZA_IO_RegWrite_16(&USB20X.CFIFOSEL, 0, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE); 00912 } 00913 00914 if (RZA_IO_RegRead_16(&USB20X.D0FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) { 00915 RZA_IO_RegWrite_16(&USB20X.D0FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE); 00916 } 00917 00918 if (RZA_IO_RegRead_16(&USB20X.D1FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) { 00919 RZA_IO_RegWrite_16(&USB20X.D1FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE); 00920 } 00921 00922 /* PIPE Configuration */ 00923 USB20X.PIPESEL = pipe; 00924 USB20X.PIPECFG = cfg->pipecfg; 00925 USB20X.PIPEBUF = cfg->pipebuf; 00926 USB20X.PIPEMAXP = cfg->pipemaxp; 00927 USB20X.PIPEPERI = cfg->pipeperi; 00928 00929 g_usbx_function_pipecfg[pipe] = cfg->pipecfg; 00930 g_usbx_function_pipebuf[pipe] = cfg->pipebuf; 00931 g_usbx_function_pipemaxp[pipe] = cfg->pipemaxp; 00932 g_usbx_function_pipeperi[pipe] = cfg->pipeperi; 00933 00934 /* Buffer Clear */ 00935 usbx_function_set_sqclr(pipe); 00936 usbx_function_aclrm(pipe); 00937 00938 /* init Global */ 00939 g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; 00940 g_usbx_function_PipeDataSize[pipe] = 0; 00941 00942 return true; 00943 } 00944 00945 00946 /*************************************************************************/ 00947 // read setup packet 00948 void USBHAL::EP0setup(uint8_t *buffer) 00949 { 00950 memcpy(buffer, setup_buffer, MAX_PACKET_SIZE_EP0); 00951 } 00952 00953 00954 /*************************************************************************/ 00955 void USBHAL::EP0readStage(void) 00956 { 00957 // No implements 00958 } 00959 00960 00961 /*************************************************************************/ 00962 void USBHAL::EP0read(void) 00963 { 00964 uint8_t *buffer; 00965 uint32_t size; 00966 00967 /* remain of last writing */ 00968 while (EP0_read_status != DEVDRV_USBF_WRITEEND) { 00969 static uint8_t bbb[2] = { 255, 255 }; 00970 EP0write(&bbb[0], 0); 00971 } 00972 00973 buffer = (uint8_t*)(&setup_buffer[4]); 00974 size = (MAX_PACKET_SIZE_EP0 / 2) - 8; 00975 usbx_api_function_CtrlWriteStart(size, buffer); 00976 } 00977 00978 00979 /*************************************************************************/ 00980 uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) 00981 { 00982 memcpy(buffer, (uint8_t*)(&setup_buffer[4]), g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0]); 00983 00984 return g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0]; 00985 } 00986 00987 00988 /*************************************************************************/ 00989 void USBHAL::EP0write(uint8_t *buffer, uint32_t size) 00990 { 00991 /* zero byte writing */ 00992 if ( (size == 0) && (EP0_read_status == DEVDRV_USBF_WRITEEND) ) { 00993 return; 00994 } 00995 00996 if (EP0_read_status == DEVDRV_USBF_WRITEEND) { 00997 /*1st block*/ 00998 EP0_read_status = usbx_api_function_CtrlReadStart(size, buffer); 00999 } else { 01000 /* waits the last transmission */ 01001 /*other blocks*/ 01002 g_usbx_function_data_count[ USB_FUNCTION_PIPE0 ] = size; 01003 g_usbx_function_data_pointer [ USB_FUNCTION_PIPE0 ] = buffer; 01004 EP0_read_status = usbx_function_write_buffer_c(USB_FUNCTION_PIPE0); 01005 } 01006 /*max size may be deblocking outside*/ 01007 if (size == MAX_PACKET_SIZE_EP0) { 01008 EP0_read_status = DEVDRV_USBF_WRITING; 01009 } 01010 } 01011 01012 01013 /*************************************************************************/ 01014 #if 0 // No implements 01015 void USBHAL::EP0getWriteResult(void) 01016 { 01017 } 01018 #endif 01019 01020 /*************************************************************************/ 01021 void USBHAL::EP0stall(void) 01022 { 01023 stallEndpoint( 0 ); 01024 } 01025 01026 01027 /*************************************************************************/ 01028 EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t max_size) 01029 { 01030 uint32_t pipe = EP2PIPE(endpoint); 01031 uint32_t pipe_size; 01032 uint16_t pipe_status; 01033 EP_STATUS status = EP_COMPLETED; 01034 01035 pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); 01036 01037 switch (pipe_status) { 01038 case DEVDRV_USBF_PIPE_IDLE: 01039 case DEVDRV_USBF_PIPE_WAIT: 01040 usbx_api_function_set_pid_nak(pipe); 01041 usbx_api_function_clear_pipe_status(pipe); 01042 01043 usbx_api_function_start_receive_transfer(pipe, max_size, recv_buffer); 01044 break; 01045 01046 default: 01047 status = EP_PENDING; 01048 break; 01049 } 01050 01051 return status; 01052 } 01053 01054 01055 /*************************************************************************/ 01056 EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t *buffer, uint32_t *bytes_read ) 01057 { 01058 uint32_t pipe = EP2PIPE(endpoint); 01059 uint16_t pipe_status; 01060 uint16_t err; 01061 EP_STATUS status = EP_PENDING; 01062 01063 01064 if (EPx_read_status != DEVDRV_USBF_PIPE_WAIT) { 01065 return status; 01066 } 01067 01068 pipe_status = usbx_api_function_check_pipe_status(pipe, bytes_read); 01069 switch (pipe_status) { 01070 case DEVDRV_USBF_PIPE_IDLE: 01071 return EP_COMPLETED; 01072 01073 case DEVDRV_USBF_PIPE_DONE: 01074 return EP_COMPLETED; 01075 01076 case DEVDRV_USBF_PIPE_WAIT: 01077 break; 01078 01079 default: 01080 return status; 01081 } 01082 01083 /* sets the output buffer and size */ 01084 g_usbx_function_data_pointer[pipe] = buffer; 01085 01086 /* receives data from pipe */ 01087 err = usbx_function_read_buffer(pipe); 01088 recv_error = err; 01089 switch (err) { 01090 case USB_FUNCTION_READEND: 01091 case USB_FUNCTION_READSHRT: 01092 case USB_FUNCTION_READOVER: 01093 *bytes_read = g_usbx_function_PipeDataSize[pipe]; 01094 break; 01095 01096 case USB_FUNCTION_READING: 01097 case DEVDRV_USBF_FIFOERROR: 01098 break; 01099 } 01100 01101 pipe_status = usbx_api_function_check_pipe_status(pipe, bytes_read); 01102 switch (pipe_status) { 01103 case DEVDRV_USBF_PIPE_DONE: 01104 status = EP_COMPLETED; 01105 break; 01106 01107 case DEVDRV_USBF_PIPE_IDLE: 01108 case DEVDRV_USBF_PIPE_NORES: 01109 case DEVDRV_USBF_PIPE_STALL: 01110 case DEVDRV_USBF_FIFOERROR: 01111 default: 01112 break; 01113 } 01114 01115 return status; 01116 } 01117 01118 01119 /*************************************************************************/ 01120 EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) 01121 { 01122 uint32_t pipe = EP2PIPE(endpoint); 01123 uint32_t pipe_size; 01124 uint16_t pipe_status; 01125 uint16_t err; 01126 uint16_t count; 01127 EP_STATUS status = EP_PENDING; 01128 01129 pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); 01130 01131 /* waits the last transmission */ 01132 count = 30000; 01133 while ((pipe_status == DEVDRV_USBF_PIPE_WAIT) || (pipe_status == DEVDRV_USBF_PIPE_DONE)) { 01134 pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); 01135 if( --count == 0 ) { 01136 pipe_status = DEVDRV_USBF_PIPE_STALL; 01137 break; 01138 } 01139 } 01140 01141 switch (pipe_status) { 01142 case DEVDRV_USBF_PIPE_IDLE: 01143 err = usbx_api_function_start_send_transfer(pipe, size, data); 01144 01145 switch (err) { 01146 /* finish to write */ 01147 case DEVDRV_USBF_WRITEEND: 01148 /* finish to write, but data is short */ 01149 case DEVDRV_USBF_WRITESHRT: 01150 /* continue to write */ 01151 case DEVDRV_USBF_WRITING: 01152 /* use DMA */ 01153 case DEVDRV_USBF_WRITEDMA: 01154 /* error */ 01155 case DEVDRV_USBF_FIFOERROR: 01156 status = EP_PENDING; 01157 break; 01158 } 01159 break; 01160 01161 case DEVDRV_USBF_PIPE_WAIT: 01162 case DEVDRV_USBF_PIPE_DONE: 01163 status = EP_PENDING; 01164 break; 01165 01166 case DEVDRV_USBF_PIPE_NORES: 01167 case DEVDRV_USBF_PIPE_STALL: 01168 default: 01169 status = EP_STALLED; 01170 break; 01171 } 01172 01173 return status; 01174 } 01175 01176 01177 /*************************************************************************/ 01178 EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) 01179 { 01180 uint32_t pipe = EP2PIPE(endpoint); 01181 uint32_t pipe_size; 01182 uint16_t pipe_status; 01183 EP_STATUS status = EP_PENDING; 01184 01185 pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); 01186 01187 switch (pipe_status) { 01188 case DEVDRV_USBF_PIPE_IDLE: 01189 status = EP_COMPLETED; 01190 break; 01191 01192 case DEVDRV_USBF_PIPE_WAIT: 01193 status = EP_PENDING; 01194 break; 01195 01196 case DEVDRV_USBF_PIPE_DONE: 01197 usbx_function_stop_transfer(pipe); 01198 status = EP_COMPLETED; 01199 break; 01200 01201 case DEVDRV_USBF_PIPE_NORES: 01202 status = EP_STALLED; 01203 break; 01204 01205 case DEVDRV_USBF_PIPE_STALL: 01206 status = EP_STALLED; 01207 break; 01208 01209 default: 01210 status = EP_PENDING; 01211 } 01212 01213 return status; 01214 } 01215 01216 01217 /*************************************************************************/ 01218 void USBHAL::stallEndpoint(uint8_t endpoint) 01219 { 01220 uint32_t pipe = EP2PIPE(endpoint); 01221 01222 usbx_function_clear_pid_stall(pipe); 01223 } 01224 01225 01226 /*************************************************************************/ 01227 void USBHAL::unstallEndpoint(uint8_t endpoint) 01228 { 01229 uint32_t pipe = EP2PIPE(endpoint); 01230 01231 usbx_function_set_pid_stall( pipe ); 01232 } 01233 01234 01235 /*************************************************************************/ 01236 bool USBHAL::getEndpointStallState(uint8_t endpoint) 01237 { 01238 // No implemens 01239 return false; 01240 } 01241 01242 01243 /*************************************************************************/ 01244 #if 0 // No implements 01245 void USBHAL::remoteWakeup(void) 01246 { 01247 } 01248 #endif 01249 01250 /*************************************************************************/ 01251 void USBHAL::_usbisr(void) 01252 { 01253 instance->usbisr(); 01254 } 01255 01256 01257 /*************************************************************************/ 01258 void USBHAL::usbisr(void) 01259 { 01260 uint16_t int_sts0; 01261 uint16_t int_sts1; 01262 uint16_t int_sts2; 01263 uint16_t int_sts3; 01264 uint16_t int_enb0; 01265 uint16_t int_enb2; 01266 uint16_t int_enb3; 01267 uint16_t int_enb4; 01268 volatile uint16_t dumy_sts; 01269 01270 01271 int_sts0 = USB20X.INTSTS0; 01272 01273 if (!(int_sts0 & ( 01274 USB_FUNCTION_BITVBINT | 01275 USB_FUNCTION_BITRESM | 01276 USB_FUNCTION_BITSOFR | 01277 USB_FUNCTION_BITDVST | 01278 USB_FUNCTION_BITCTRT | 01279 USB_FUNCTION_BITBEMP | 01280 USB_FUNCTION_BITNRDY | 01281 USB_FUNCTION_BITBRDY ))) { 01282 return; 01283 } 01284 01285 int_sts1 = USB20X.BRDYSTS; 01286 int_sts2 = USB20X.NRDYSTS; 01287 int_sts3 = USB20X.BEMPSTS; 01288 int_enb0 = USB20X.INTENB0; 01289 int_enb2 = USB20X.BRDYENB; 01290 int_enb3 = USB20X.NRDYENB; 01291 int_enb4 = USB20X.BEMPENB; 01292 01293 if ((int_sts0 & USB_FUNCTION_BITRESM) && 01294 (int_enb0 & USB_FUNCTION_BITRSME)) { 01295 USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITRESM; 01296 RZA_IO_RegWrite_16(&USB20X.INTENB0, 0, USB_INTENB0_RSME_SHIFT, USB_INTENB0_RSME); 01297 /*usbx_function_USB_FUNCTION_Resume();*/ 01298 suspendStateChanged(1); 01299 } else if ( 01300 (int_sts0 & USB_FUNCTION_BITVBINT) && 01301 (int_enb0 & USB_FUNCTION_BITVBSE)) { 01302 USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVBINT; 01303 01304 if (usbx_function_CheckVBUStaus() == DEVDRV_USBF_ON) { 01305 usbx_function_USB_FUNCTION_Attach(); 01306 } else { 01307 usbx_function_USB_FUNCTION_Detach(); 01308 } 01309 } else if ( 01310 (int_sts0 & USB_FUNCTION_BITSOFR) && 01311 (int_enb0 & USB_FUNCTION_BITSOFE)) { 01312 USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITSOFR; 01313 SOF((USB20X.FRMNUM & USB_FRMNUM_FRNM) >> USB_FRMNUM_FRNM_SHIFT); 01314 } else if ( 01315 (int_sts0 & USB_FUNCTION_BITDVST) && 01316 (int_enb0 & USB_FUNCTION_BITDVSE)) { 01317 USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITDVST; 01318 switch (int_sts0 & USB_FUNCTION_BITDVSQ) { 01319 case USB_FUNCTION_DS_POWR: 01320 break; 01321 01322 case USB_FUNCTION_DS_DFLT: 01323 /***************************************************************************** 01324 * Function Name: usbx_function_USB_FUNCTION_BusReset 01325 * Description : This function is executed when the USB device is transitioned 01326 * : to POWERD_STATE. Sets the device descriptor according to the 01327 * : connection speed determined by the USB reset hand shake. 01328 * Arguments : none 01329 * Return Value : none 01330 *****************************************************************************/ 01331 usbx_function_init_status(); /* memory clear */ 01332 01333 #if 0 01334 /* You would program those steps in USBCallback_busReset 01335 * if the system need the comment out steps. 01336 */ 01337 01338 if (usbx_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED) { 01339 /* Device Descriptor reset */ 01340 usbx_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED); 01341 } else { 01342 /* Device Descriptor reset */ 01343 usbx_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED); 01344 } 01345 #endif 01346 /* Default Control PIPE reset */ 01347 /***************************************************************************** 01348 * Function Name: usbx_function_ResetDCP 01349 * Description : Initializes the default control pipe(DCP). 01350 * Outline : Reset default control pipe 01351 * Arguments : none 01352 * Return Value : none 01353 *****************************************************************************/ 01354 USB20X.DCPCFG = 0; 01355 USB20X.DCPMAXP = 64; /*TODO: This value is copied from sample*/ 01356 01357 USB20X.CFIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); 01358 USB20X.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); 01359 USB20X.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); 01360 01361 busReset(); 01362 break; 01363 01364 case USB_FUNCTION_DS_ADDS: 01365 break; 01366 01367 case USB_FUNCTION_DS_CNFG: 01368 break; 01369 01370 case USB_FUNCTION_DS_SPD_POWR: 01371 case USB_FUNCTION_DS_SPD_DFLT: 01372 case USB_FUNCTION_DS_SPD_ADDR: 01373 case USB_FUNCTION_DS_SPD_CNFG: 01374 suspendStateChanged(0); 01375 /*usbx_function_USB_FUNCTION_Suspend();*/ 01376 break; 01377 01378 default: 01379 break; 01380 } 01381 } else if ( 01382 (int_sts0 & USB_FUNCTION_BITBEMP) && 01383 (int_enb0 & USB_FUNCTION_BITBEMP) && 01384 ((int_sts3 & int_enb4) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) { 01385 /* ==== BEMP PIPE0 ==== */ 01386 usbx_function_BEMPInterruptPIPE0(int_sts3, int_enb4, this, &USBHAL::EP0in); 01387 } else if ( 01388 (int_sts0 & USB_FUNCTION_BITBRDY) && 01389 (int_enb0 & USB_FUNCTION_BITBRDY) && 01390 ((int_sts1 & int_enb2) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) { 01391 /* ==== BRDY PIPE0 ==== */ 01392 usbx_function_BRDYInterruptPIPE0(int_sts1, int_enb2, this, &USBHAL::EP0out); 01393 } else if ( 01394 (int_sts0 & USB_FUNCTION_BITNRDY) && 01395 (int_enb0 & USB_FUNCTION_BITNRDY) && 01396 ((int_sts2 & int_enb3) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) { 01397 /* ==== NRDY PIPE0 ==== */ 01398 usbx_function_NRDYInterruptPIPE0(int_sts2, int_enb3, this, NULL); 01399 } else if ( 01400 (int_sts0 & USB_FUNCTION_BITCTRT) && (int_enb0 & USB_FUNCTION_BITCTRE)) { 01401 int_sts0 = USB20X.INTSTS0; 01402 USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITCTRT; 01403 01404 if (((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_RDDS) || 01405 ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRDS) || 01406 ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRND)) { 01407 01408 /* remake EP0 into buffer */ 01409 usbx_function_save_request(); 01410 if ((USB20X.INTSTS0 & USB_FUNCTION_BITVALID) && ( 01411 ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_RDDS) || 01412 ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRDS) || 01413 ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRND))) { 01414 /* New SETUP token received */ 01415 /* Three dummy reads for cleearing interrupt requests */ 01416 dumy_sts = USB20X.INTSTS0; 01417 dumy_sts = USB20X.INTSTS0; 01418 dumy_sts = USB20X.INTSTS0; 01419 return; 01420 } 01421 } 01422 01423 switch (int_sts0 & USB_FUNCTION_BITCTSQ) { 01424 case USB_FUNCTION_CS_IDST: 01425 if (g_usbx_function_TestModeFlag == DEVDRV_USBF_YES) { 01426 /* ==== Test Mode ==== */ 01427 usbx_function_USB_FUNCTION_TestMode(); 01428 } 01429 /* Needs not procedure in this state */ 01430 break; 01431 01432 case USB_FUNCTION_CS_RDDS: 01433 /* Reads a setup packet */ 01434 EP0setupCallback(); 01435 break; 01436 01437 case USB_FUNCTION_CS_WRDS: 01438 /* Original code was the SetDescriptor was called */ 01439 EP0setupCallback(); 01440 break; 01441 01442 case USB_FUNCTION_CS_WRND: 01443 EP0setupCallback(); 01444 01445 /*The EP0setupCallback should finish in successful */ 01446 usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); 01447 01448 RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL); 01449 break; 01450 01451 case USB_FUNCTION_CS_RDSS: 01452 RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL); 01453 break; 01454 01455 case USB_FUNCTION_CS_WRSS: 01456 RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL); 01457 break; 01458 01459 case USB_FUNCTION_CS_SQER: 01460 usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); 01461 break; 01462 01463 default: 01464 usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); 01465 break; 01466 } 01467 } else if ( 01468 (int_sts0 & USB_FUNCTION_BITBEMP) && 01469 (int_enb0 & USB_FUNCTION_BITBEMP) && 01470 (int_sts3 & int_enb4) ) { 01471 /* ==== BEMP PIPEx ==== */ 01472 usbx_function_BEMPInterrupt(int_sts3, int_enb4, this, epCallback); 01473 } else if ( 01474 (int_sts0 & USB_FUNCTION_BITBRDY) && 01475 (int_enb0 & USB_FUNCTION_BITBRDY) && 01476 (int_sts1 & int_enb2) ) { 01477 /* ==== BRDY PIPEx ==== */ 01478 usbx_function_BRDYInterrupt(int_sts1, int_enb2, this, epCallback); 01479 } else if ( 01480 (int_sts0 & USB_FUNCTION_BITNRDY) && 01481 (int_enb0 & USB_FUNCTION_BITNRDY) && 01482 (int_sts2 & int_enb3)) { 01483 /* ==== NRDY PIPEx ==== */ 01484 usbx_function_NRDYInterrupt(int_sts2, int_enb3, this, epCallback); 01485 } else { 01486 /* Do Nothing */ 01487 } 01488 01489 /* Three dummy reads for cleearing interrupt requests */ 01490 dumy_sts = USB20X.INTSTS0; 01491 dumy_sts = USB20X.INTSTS1; 01492 } 01493 01494 /*************************************************************************/ 01495 #endif 01496 /*************************************************************************/ 01497 /*EOF*/
Generated on Wed Jul 13 2022 12:44:03 by
1.7.2