mbed official
USB device stack
Dependents: mbed-mX-USB-TEST1 USBMSD_SD_HID_HelloWorld HidTest MIDI_usb_bridge ... more
Legacy Warning
This is an mbed 2 library. To learn more about mbed OS 5, visit the docs.
Pull requests against this repository are no longer supported. Please raise against mbed OS 5 as documented above.
Diff: USBDevice/USBHAL_RZ_A1H.cpp
- Revision:
- 71:53949e6131f6
- Parent:
- 70:2c525a50f1b6
--- a/USBDevice/USBHAL_RZ_A1H.cpp Thu Jul 20 10:14:36 2017 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1497 +0,0 @@
-/* Copyright (c) 2010-2011 mbed.org, MIT License
-*
-* Permission is hereby granted, free of charge, to any person
-* obtaining a copy of this software and associated documentation
-* files (the "Software"), to deal in the Software without
-* restriction, including without limitation the rights to use,
-* copy, modify, merge, publish, distribute, sublicense, and/or
-* sell copies of the Software, and to permit persons to whom the
-* Software is furnished to do so, subject to the following
-* conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the
-* Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-* KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#if defined(TARGET_RZ_A1H) || defined(TARGET_VK_RZ_A1H)
-
-/*
- This class can use the pipe1, pipe3 and pipe6 only. You should
- re-program this class if you wanted to use other pipe.
- */
-
-/*************************************************************************/
-extern "C"
-{
-#include "r_typedefs.h"
-#include "iodefine.h"
-}
-#include "USBHAL.h"
-#include "devdrv_usb_function_api.h"
-#include "usb_iobitmask.h"
-#include "rza_io_regrw.h"
-#include "USBDevice_Types.h"
-#include "usb_function_setting.h"
-
-
-/*************************************************************************/
-/* constants */
-const struct PIPECFGREC {
- uint16_t endpoint;
- uint16_t pipesel;
- uint16_t pipecfg;
- uint16_t pipebuf;
- uint16_t pipemaxp;
- uint16_t pipeperi;
-} def_pipecfg[] = {
- /*EP0OUT and EP0IN are configured by USB IP*/
- {
- EP1OUT, /*EP1: Host -> Func, INT*/
- 6 | USB_FUNCTION_D0FIFO_USE,
- USB_FUNCTION_INTERRUPT |
- USB_FUNCTION_BFREOFF |
- USB_FUNCTION_DBLBOFF |
- USB_FUNCTION_CNTMDON |
- USB_FUNCTION_SHTNAKOFF |
- USB_FUNCTION_DIR_P_OUT |
- USB_FUNCTION_EP1,
- ( ( ( 64) / 64 - 1 ) << 10 ) | 0x04u,
- MAX_PACKET_SIZE_EP1,
- DEVDRV_USBF_OFF |
- ( 3 << USB_PIPEPERI_IITV_SHIFT ),
- },
- {
- EP1IN, /*EP1: Host <- Func, INT*/
- 7 | USB_FUNCTION_D1FIFO_USE,
- USB_FUNCTION_INTERRUPT |
- USB_FUNCTION_BFREOFF |
- USB_FUNCTION_DBLBOFF |
- USB_FUNCTION_CNTMDOFF |
- USB_FUNCTION_SHTNAKOFF |
- USB_FUNCTION_DIR_P_IN |
- USB_FUNCTION_EP1,
- ( ( ( 64) / 64 - 1 ) << 10 ) | 0x05u,
- MAX_PACKET_SIZE_EP1,
- DEVDRV_USBF_OFF |
- ( 3 << USB_PIPEPERI_IITV_SHIFT ),
- },
- {
- EP2OUT, /*EP2: Host -> Func, BULK*/
- 3 | USB_FUNCTION_D0FIFO_USE,
- USB_FUNCTION_BULK |
- USB_FUNCTION_BFREOFF |
- USB_FUNCTION_DBLBON |
- USB_FUNCTION_CNTMDON |
- USB_FUNCTION_SHTNAKON |
- USB_FUNCTION_DIR_P_OUT |
- USB_FUNCTION_EP2,
- ( ( (2048) / 64 - 1 ) << 10 ) | 0x30u,
- MAX_PACKET_SIZE_EP2,
- DEVDRV_USBF_OFF |
- ( 0 << USB_PIPEPERI_IITV_SHIFT ),
- },
- {
- EP2IN, /*EP2: Host <- Func, BULK*/
- 4 | USB_FUNCTION_D1FIFO_USE,
- USB_FUNCTION_BULK |
- USB_FUNCTION_BFREOFF |
- USB_FUNCTION_DBLBOFF |
- USB_FUNCTION_CNTMDON |
- USB_FUNCTION_SHTNAKOFF |
- USB_FUNCTION_DIR_P_IN |
- USB_FUNCTION_EP2,
- ( ( (2048) / 64 - 1 ) << 10 ) | 0x50u,
- MAX_PACKET_SIZE_EP2,
- DEVDRV_USBF_OFF |
- ( 0 << USB_PIPEPERI_IITV_SHIFT ),
- },
- {
- EP3OUT, /*EP3: Host -> Func, ISO*/
- 1 | USB_FUNCTION_D0FIFO_USE,
- USB_FUNCTION_ISO |
- USB_FUNCTION_BFREOFF |
- USB_FUNCTION_DBLBON |
- USB_FUNCTION_CNTMDOFF |
- USB_FUNCTION_SHTNAKON |
- USB_FUNCTION_DIR_P_OUT |
- USB_FUNCTION_EP3,
- ( ( ( 512) / 64 - 1 ) << 10 ) | 0x10u,
- MAX_PACKET_SIZE_EP3,
- DEVDRV_USBF_OFF |
- ( 0 << USB_PIPEPERI_IITV_SHIFT ),
- },
- {
- EP3IN, /*EP3: Host <- Func, ISO*/
- 2 | USB_FUNCTION_D1FIFO_USE,
- USB_FUNCTION_ISO |
- USB_FUNCTION_BFREOFF |
- USB_FUNCTION_DBLBON |
- USB_FUNCTION_CNTMDOFF |
- USB_FUNCTION_SHTNAKOFF |
- USB_FUNCTION_DIR_P_IN |
- USB_FUNCTION_EP3,
- ( ( ( 512) / 64 - 1 ) << 10 ) | 0x20u,
- MAX_PACKET_SIZE_EP3,
- DEVDRV_USBF_OFF |
- ( 0 << USB_PIPEPERI_IITV_SHIFT ),
- },
- { /*terminator*/
- 0, 0, 0, 0, 0,
- },
-};
-
-
-/*************************************************************************/
-/* workareas */
-USBHAL * USBHAL::instance;
-
-static IRQn_Type int_id; /* interrupt ID */
-static uint16_t int_level; /* initerrupt level */
-static uint16_t clock_mode; /* input clock selector */
-static uint16_t mode; /* USB speed (HIGH/FULL) */
-
-//static DigitalOut *usbx_en;
-
-static uint16_t EP0_read_status;
-static uint16_t EPx_read_status;
-
-static uint16_t setup_buffer[MAX_PACKET_SIZE_EP0 / 2];
-
-/* 0: not used / other: a pipe number to use recv_buffer*/
-static uint8_t recv_buffer[MAX_PACKET_SIZE_EPBULK];
-volatile static uint16_t recv_error;
-
-
-/*************************************************************************/
-/* prototypes for C */
-extern "C" {
- void usbx_function_BRDYInterruptPIPE0 (uint16_t status, uint16_t intenb,
- USBHAL *object, void (USBHAL::*EP0func)(void));
-
- void usbx_function_BRDYInterrupt (uint16_t status, uint16_t intenb,
- USBHAL *object, bool (USBHAL::*epCallback[])(void));
-
- void usbx_function_NRDYInterruptPIPE0(uint16_t status, uint16_t intenb,
- USBHAL *object, void (USBHAL::*EP0func)(void));
-
- void usbx_function_NRDYInterrupt (uint16_t status, uint16_t intenb,
- USBHAL *object, bool (USBHAL::*epCallback[])(void));
-
- void usbx_function_BEMPInterruptPIPE0(uint16_t status, uint16_t intenb,
- USBHAL *object, void (USBHAL::*EP0func)(void));
-
- void usbx_function_BEMPInterrupt (uint16_t status, uint16_t intenb,
- USBHAL *object, bool (USBHAL::*epCallback[])(void));
-}
-
-
-/*************************************************************************/
-/* macros */
-
-/******************************************************************************
- * Function Name: usbx_function_BRDYInterruptPIPE0
- * Description : Executes BRDY interrupt for pipe0.
- * Arguments : uint16_t status ; BRDYSTS Register Value
- * : uint16_t intenb ; BRDYENB Register Value
- * Return Value : none
- *****************************************************************************/
-extern "C" {
- void usbx_function_BRDYInterruptPIPE0 (
- uint16_t status,
- uint16_t intenb,
- USBHAL *object,
- void (USBHAL::*EP0func)(void)
- )
- {
- volatile uint16_t dumy_sts;
- uint16_t read_status;
-
- USB20X.BRDYSTS =
- (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0];
- RZA_IO_RegWrite_16(
- &USB20X.CFIFOSEL, USB_FUNCTION_PIPE0,
- USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE);
-
- g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0] =
- g_usbx_function_data_count[USB_FUNCTION_PIPE0];
-
- read_status = usbx_function_read_buffer_c(USB_FUNCTION_PIPE0);
-
- g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0] -=
- g_usbx_function_data_count[USB_FUNCTION_PIPE0];
-
- switch (read_status) {
- case USB_FUNCTION_READING: /* Continue of data read */
- case USB_FUNCTION_READEND: /* End of data read */
- /* PID = BUF */
- usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);
-
- /*callback*/
- (object->*EP0func)();
- break;
-
- case USB_FUNCTION_READSHRT: /* End of data read */
- usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0);
- /* PID = BUF */
- usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);
-
- /*callback*/
- (object->*EP0func)();
- break;
-
- case USB_FUNCTION_READOVER: /* FIFO access error */
- /* Buffer Clear */
- USB20X.CFIFOCTR = USB_FUNCTION_BITBCLR;
- usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0);
- /* Req Error */
- usbx_function_set_pid_stall(USB_FUNCTION_PIPE0);
-
- /*callback*/
- (object->*EP0func)();
- break;
-
- case DEVDRV_USBF_FIFOERROR: /* FIFO access error */
- default:
- usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0);
- /* Req Error */
- usbx_function_set_pid_stall(USB_FUNCTION_PIPE0);
- break;
- }
- /* Three dummy reads for clearing interrupt requests */
- dumy_sts = USB20X.BRDYSTS;
- }
-}
-
-
-/******************************************************************************
- * Function Name: usbx_function_BRDYInterrupt
- * Description : Executes BRDY interrupt uxclude pipe0.
- * Arguments : uint16_t status ; BRDYSTS Register Value
- * : uint16_t intenb ; BRDYENB Register Value
- * Return Value : none
- *****************************************************************************/
-extern "C" {
- void usbx_function_BRDYInterrupt(
- uint16_t status,
- uint16_t intenb,
- USBHAL *object,
- bool (USBHAL::*epCallback[])(void)
- )
- {
- volatile uint16_t dumy_sts;
-
- /**************************************************************
- * Function Name: usbx_function_brdy_int
- * Description : Executes BRDY interrupt(USB_FUNCTION_PIPE1-9).
- * : According to the pipe that interrupt is generated in,
- * : reads/writes buffer allocated in the pipe.
- * : This function is executed in the BRDY
- * : interrupt handler. This function
- * : clears BRDY interrupt status and BEMP
- * : interrupt status.
- * Arguments : uint16_t Status ; BRDYSTS Register Value
- * : uint16_t Int_enbl ; BRDYENB Register Value
- * Return Value : none
- *************************************************************/
- /* copied from usbx_function_intrn.c */
- uint32_t int_sense = 0;
- uint16_t pipe;
- uint16_t pipebit;
- uint16_t ep;
-
- for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) {
- pipebit = g_usbx_function_bit_set[pipe];
-
- if ((status & pipebit) && (intenb & pipebit)) {
- USB20X.BRDYSTS = (uint16_t)~pipebit;
- USB20X.BEMPSTS = (uint16_t)~pipebit;
-
- switch (g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) {
- case USB_FUNCTION_D0FIFO_DMA:
- if (g_usbx_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY) {
- /*now, DMA is not supported*/
- usbx_function_dma_interrupt_d0fifo(int_sense);
- }
-
- if (RZA_IO_RegRead_16(
- &g_usbx_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) {
- /*now, DMA is not supported*/
- usbx_function_read_dma(pipe);
- usbx_function_disable_brdy_int(pipe);
- } else {
- USB20X.D0FIFOCTR = USB_FUNCTION_BITBCLR;
- g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
- }
- break;
-
- case USB_FUNCTION_D1FIFO_DMA:
- if (g_usbx_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY) {
- /*now, DMA is not supported*/
- usbx_function_dma_interrupt_d1fifo(int_sense);
- }
-
- if (RZA_IO_RegRead_16(
- &g_usbx_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) {
- /*now, DMA is not supported*/
- usbx_function_read_dma(pipe);
- usbx_function_disable_brdy_int(pipe);
- } else {
- USB20X.D1FIFOCTR = USB_FUNCTION_BITBCLR;
- g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
- }
- break;
-
- default:
- ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT;
- ep <<= 1;
- if (RZA_IO_RegRead_16(
- &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) {
- /* read */
- EPx_read_status = DEVDRV_USBF_PIPE_WAIT;
- (object->*(epCallback[ep - 2])) ();
- EPx_read_status = DEVDRV_USBF_PIPE_DONE;
- } else {
- /* write */
- EPx_read_status = DEVDRV_USBF_PIPE_WAIT;
- (object->*(epCallback[ep - 2 + 1])) ();
- EPx_read_status = DEVDRV_USBF_PIPE_DONE;
- usbx_function_write_buffer(pipe);
- }
- }
- }
- }
- /* Three dummy reads for clearing interrupt requests */
- dumy_sts = USB20X.BRDYSTS;
- }
-}
-
-
-/******************************************************************************
- * Function Name: usbx_function_NRDYInterruptPIPE0
- * Description : Executes NRDY interrupt for pipe0.
- * Arguments : uint16_t status ; NRDYSTS Register Value
- * : uint16_t intenb ; NRDYENB Register Value
- * Return Value : none
- *****************************************************************************/
-extern "C" {
- void usbx_function_NRDYInterruptPIPE0(
- uint16_t status,
- uint16_t intenb,
- USBHAL *object,
- void (USBHAL::*EP0func)(void)
- )
- {
- volatile uint16_t dumy_sts;
-
- USB20X.NRDYSTS =
- (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0];
-
- /* Three dummy reads for clearing interrupt requests */
- dumy_sts = USB20X.NRDYSTS;
- }
-}
-
-
-/******************************************************************************
- * Function Name: usbx_function_NRDYInterrupt
- * Description : Executes NRDY interrupt exclude pipe0.
- * Arguments : uint16_t status ; NRDYSTS Register Value
- * : uint16_t intenb ; NRDYENB Register Value
- * Return Value : none
- *****************************************************************************/
-extern "C" {
- void usbx_function_NRDYInterrupt(
- uint16_t status,
- uint16_t intenb,
- USBHAL *object,
- bool (USBHAL::*epCallback[])(void)
- )
- {
- volatile uint16_t dumy_sts;
-
- /**************************************************************
- * Function Name: usbx_function_nrdy_int
- * Description : Executes NRDY interrupt(USB_FUNCTION_PIPE1-9).
- * : Checks NRDY interrupt cause by PID. When the cause if STALL,
- * : regards the pipe state as STALL and ends the processing.
- * : Then the cause is not STALL, increments the error count to
- * : communicate again. When the error count is 3, determines
- * : the pipe state as DEVDRV_USBF_PIPE_NORES and ends the processing.
- * : This function is executed in the NRDY interrupt handler.
- * : This function clears NRDY interrupt status.
- * Arguments : uint16_t status ; NRDYSTS Register Value
- * : uint16_t int_enb ; NRDYENB Register Value
- * Return Value : none
- *************************************************************/
- /* copied from usbx_function_intrn.c */
-#if 0
- uint16_t usefifo;
-#endif
- uint16_t pid;
- uint16_t pipe;
- uint16_t bitcheck;
-#if 0
- uint16_t mbw;
- uint32_t size;
-#endif
- uint16_t ep;
-
- bitcheck = (uint16_t)(status & intenb);
-
- USB20X.NRDYSTS = (uint16_t)~status;
-
-
- if (RZA_IO_RegRead_16(&USB20X.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1) {
- /* USB HOST */
- /* not support */
-
- } else {
- /* USB Function */
- for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) {
- if ((bitcheck&g_usbx_function_bit_set[pipe]) != g_usbx_function_bit_set[pipe]) {
- continue;
- }
-
- if (g_usbx_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_WAIT) {
- continue;
- }
-
-#if 0
- usbx_function_set_pid_nak(pipe);
-
- size = (uint32_t)g_usbx_function_data_count[pipe];
- mbw = usbx_function_get_mbw(
- size, (uint32_t)g_usbx_function_data_pointer[pipe]);
-
- usefifo = (uint16_t)(g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
- switch (usefifo) {
-
- case USB_FUNCTION_D0FIFO_USE:
- usbx_function_set_curpipe(
- pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
- USB20X.D0FIFOCTR = USB_FUNCTION_BITBCLR;
- break;
-
- case USB_FUNCTION_D1FIFO_USE:
- usbx_function_set_curpipe(
- pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
- USB20X.D1FIFOCTR = USB_FUNCTION_BITBCLR;
- break;
-
- default:
- usbx_function_set_curpipe(
- pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw);
- USB20X.CFIFOCTR = USB_FUNCTION_BITBCLR;
- break;
- }
-
- usbx_function_aclrm(pipe);
-
- usbx_function_enable_nrdy_int(pipe);
- usbx_function_enable_brdy_int(pipe);
-
- usbx_function_set_pid_buf(pipe);
-#endif
-
- pid = usbx_function_get_pid(pipe);
- if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) {
- g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL;
- } else {
- usbx_function_set_pid_buf(pipe);
- }
-
- ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT;
- ep <<= 1;
- if (RZA_IO_RegRead_16(
- &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) {
- /* read */
- __NOP();
- } else {
- /* write */
- __NOP();
- }
- }
- }
-
- /* Three dummy reads for clearing interrupt requests */
- dumy_sts = USB20X.NRDYSTS;
- }
-}
-
-/******************************************************************************
- * Function Name: usbx_function_BEMPInterruptPIPE0
- * Description : Executes BEMP interrupt for pipe0.
- * Arguments : uint16_t status ; BEMPSTS Register Value
- * : uint16_t intenb ; BEMPENB Register Value
- * Return Value : none
- *****************************************************************************/
-extern "C" {
- void usbx_function_BEMPInterruptPIPE0(
- uint16_t status,
- uint16_t intenb,
- USBHAL *object,
- void (USBHAL::*EP0func)(void)
- )
- {
- volatile uint16_t dumy_sts;
-
- USB20X.BEMPSTS =
- (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0];
- RZA_IO_RegWrite_16(
- &USB20X.CFIFOSEL, USB_FUNCTION_PIPE0,
- USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE);
-
- /*usbx_function_write_buffer_c(USB_FUNCTION_PIPE0);*/
- (object->*EP0func)();
-
- /* Three dummy reads for clearing interrupt requests */
- dumy_sts = USB20X.BEMPSTS;
- }
-}
-
-
-/******************************************************************************
- * Function Name: usbx_function_BEMPInterrupt
- * Description : Executes BEMP interrupt exclude pipe0.
- * Arguments : uint16_t status ; BEMPSTS Register Value
- * : uint16_t intenb ; BEMPENB Register Value
- * Return Value : none
- *****************************************************************************/
-extern "C" {
- void usbx_function_BEMPInterrupt(
- uint16_t status,
- uint16_t intenb,
- USBHAL *object,
- bool (USBHAL::*epCallback[])(void)
- )
- {
- volatile uint16_t dumy_sts;
-
- /**************************************************************
- * Function Name: usbx_function_bemp_int
- * Description : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9).
- * Arguments : uint16_t status ; BEMPSTS Register Value
- * : uint16_t intenb ; BEMPENB Register Value
- * Return Value : none
- *************************************************************/
- /* copied from usbx_function_intrn.c */
- uint16_t pid;
- uint16_t pipe;
- uint16_t bitcheck;
- uint16_t inbuf;
- uint16_t ep;
-
- bitcheck = (uint16_t)(status & intenb);
-
- USB20X.BEMPSTS = (uint16_t)~status;
-
- for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) {
- if ((bitcheck&g_usbx_function_bit_set[pipe]) != g_usbx_function_bit_set[pipe]) {
- continue;
- }
-
- pid = usbx_function_get_pid(pipe);
-
- if ((pid == DEVDRV_USBF_PID_STALL) ||
- (pid == DEVDRV_USBF_PID_STALL2)) {
- g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL;
-
- } else {
- inbuf = usbx_function_get_inbuf(pipe);
-
- if (inbuf == 0) {
- usbx_function_disable_bemp_int(pipe);
- usbx_function_set_pid_nak(pipe);
- g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
-
- switch (g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) {
- case USB_FUNCTION_D0FIFO_DMA:
- /*now, DMA is not supported*/
- break;
-
- case USB_FUNCTION_D1FIFO_DMA:
- /*now, DMA is not supported*/
- break;
-
- default:
- ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT;
- ep <<= 1;
- if (RZA_IO_RegRead_16(
- &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) {
- /* read */
- __NOP();
- } else {
- /* write */
- EPx_read_status = DEVDRV_USBF_PIPE_WAIT;
- (object->*(epCallback[ep - 2 + 1])) ();
- EPx_read_status = DEVDRV_USBF_PIPE_DONE;
- }
- }
- }
- }
- }
-
- /* Three dummy reads for clearing interrupt requests */
- dumy_sts = USB20X.BEMPSTS;
- }
-}
-
-/******************************************************************************
- * Function Name: EP2PIPE
- * Description : Converts from endpoint to pipe
- * Arguments : number of endpoint
- * Return Value : number of pipe
- *****************************************************************************/
-/*EP2PIPE converter is for pipe1, pipe3 and pipe6 only.*/
-#define EP2PIPE(endpoint) ((uint32_t)usbx_function_EpToPipe(endpoint))
-
-
-/******************************************************************************
- * Function Name: usbx_function_save_request
- * Description : Retains the USB request information in variables.
- * Arguments : none
- * Return Value : none
- *****************************************************************************/
-#define usbx_function_save_request() \
- { \
- uint16_t *bufO = &setup_buffer[0]; \
- \
- USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVALID; \
- /*data[0] <= bmRequest, data[1] <= bmRequestType */ \
- *bufO++ = USB20X.USBREQ; \
- /*data[2] data[3] <= wValue*/ \
- *bufO++ = USB20X.USBVAL; \
- /*data[4] data[5] <= wIndex*/ \
- *bufO++ = USB20X.USBINDX; \
- /*data[6] data[6] <= wIndex*/ \
- *bufO++ = USB20X.USBLENG; \
- }
-
-
-/*************************************************************************/
-/*************************************************************************/
-/*************************************************************************/
-
-/*************************************************************************/
-/* constructor */
-USBHAL::USBHAL(void)
-{
- /* ---- P4_1 : P4_1 (USB0_EN for GR-PEACH) ---- */
- //usbx_en = new DigitalOut(P4_1, 1);
-
- /* some constants */
- int_id = USBIX_IRQn;
- int_level = ( 2 << 3 );
- clock_mode = USBFCLOCK_X1_48MHZ;
-#if (USB_FUNCTION_HISPEED == 0)
- mode = USB_FUNCTION_FULL_SPEED;
-#else
- mode = USB_FUNCTION_HIGH_SPEED;
-#endif
- EP0_read_status = DEVDRV_USBF_WRITEEND;
- EPx_read_status = DEVDRV_USBF_PIPE_DONE;
-
- /* Disables interrupt for usb */
- GIC_DisableIRQ(int_id);
-
- /* Setup the end point */
- epCallback[ 0] = &USBHAL::EP1_OUT_callback;
- epCallback[ 1] = &USBHAL::EP1_IN_callback;
- epCallback[ 2] = &USBHAL::EP2_OUT_callback;
- epCallback[ 3] = &USBHAL::EP2_IN_callback;
- epCallback[ 4] = &USBHAL::EP3_OUT_callback;
- epCallback[ 5] = &USBHAL::EP3_IN_callback;
- epCallback[ 6] = &USBHAL::EP4_OUT_callback;
- epCallback[ 7] = &USBHAL::EP4_IN_callback;
- epCallback[ 8] = &USBHAL::EP5_OUT_callback;
- epCallback[ 9] = &USBHAL::EP5_IN_callback;
- epCallback[10] = &USBHAL::EP6_OUT_callback;
- epCallback[11] = &USBHAL::EP6_IN_callback;
- epCallback[12] = &USBHAL::EP7_OUT_callback;
- epCallback[13] = &USBHAL::EP7_IN_callback;
- epCallback[14] = &USBHAL::EP8_OUT_callback;
- epCallback[15] = &USBHAL::EP8_IN_callback;
- epCallback[16] = &USBHAL::EP9_OUT_callback;
- epCallback[17] = &USBHAL::EP9_IN_callback;
- epCallback[18] = &USBHAL::EP10_OUT_callback;
- epCallback[19] = &USBHAL::EP10_IN_callback;
- epCallback[20] = &USBHAL::EP11_OUT_callback;
- epCallback[21] = &USBHAL::EP11_IN_callback;
- epCallback[22] = &USBHAL::EP12_OUT_callback;
- epCallback[23] = &USBHAL::EP12_IN_callback;
- epCallback[24] = &USBHAL::EP13_OUT_callback;
- epCallback[25] = &USBHAL::EP13_IN_callback;
- epCallback[26] = &USBHAL::EP14_OUT_callback;
- epCallback[27] = &USBHAL::EP14_IN_callback;
- epCallback[28] = &USBHAL::EP15_OUT_callback;
- epCallback[29] = &USBHAL::EP15_IN_callback;
-
- /* registers me */
- instance = this;
-
- /* Clear pipe table */
- usbx_function_clear_pipe_tbl();
-
-/******************************************************************************
- * Function Name: usbx_api_function_init
- * Description : Initializes the USB module in the USB function mode.
- *****************************************************************************/
- /* The clock of USB0 modules is permitted */
-#if (USB_FUNCTION_CH == 0)
- CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71);
-#else
- CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71 | CPG_STBCR7_MSTP70);
-#endif
- volatile uint8_t dummy8;
- dummy8 = CPG.STBCR7;
-
- {
-/******************************************************************************
- * Function Name: usbx_function_setting_interrupt
- * Description : Sets the USB module interrupt level.
- *****************************************************************************/
-#if 0 /*DMA is not supported*/
- IRQn_Type d0fifo_dmaintid;
- IRQn_Type d1fifo_dmaintid;
-#endif
-
- InterruptHandlerRegister(int_id, &_usbisr);
- GIC_SetPriority(int_id, int_level);
- GIC_EnableIRQ(int_id);
-
-#if 0 /*DMA is not supported*/
- d0fifo_dmaintid = Userdef_USB_usbx_function_d0fifo_dmaintid();
- if (d0fifo_dmaintid != 0xFFFF) {
- InterruptHandlerRegister(d0fifo_dmaintid, usbx_function_dma_interrupt_d0fifo);
- GIC_SetPriority(d0fifo_dmaintid, int_level);
- GIC_EnableIRQ(d0fifo_dmaintid);
- }
-#endif
-
-#if 0 /*DMA is not supported*/
- d1fifo_dmaintid = Userdef_USB_usbx_function_d1fifo_dmaintid();
- if (d1fifo_dmaintid != 0xFFFF) {
- InterruptHandlerRegister(d1fifo_dmaintid, usbx_function_dma_interrupt_d1fifo);
- GIC_SetPriority(d1fifo_dmaintid, int_level);
- GIC_EnableIRQ(d1fifo_dmaintid);
- }
-#endif
-/*****************************************************************************/
- }
-
- /* reset USB module with setting tranciever and HSE=1 */
- usbx_function_reset_module(clock_mode);
-
- /* clear variables */
- usbx_function_init_status();
-
- /* select USB Function and Interrupt Enable */
- /* Detect USB Device to attach or detach */
- usbx_function_InitModule(mode);
-
- {
- uint16_t buf;
- buf = USB20X.INTENB0;
- buf |= USB_INTENB0_SOFE;
- USB20X.INTENB0 = buf;
- }
-}
-
-/*************************************************************************/
-USBHAL::~USBHAL(void)
-{
- /* Disables interrupt for usb */
- GIC_DisableIRQ( int_id );
- /* Unregisters interrupt function and priority */
- InterruptHandlerRegister( int_id, (uint32_t)NULL );
-
- //usbx_en = NULL;
- instance = NULL;
-}
-
-/*************************************************************************/
-void USBHAL::connect(void)
-{
- /* Activates USB0_EN */
- //(*usbx_en) = 0;
-}
-
-
-/*************************************************************************/
-void USBHAL::disconnect(void)
-{
- /* Deactivates USB0_EN */
- //(*usbx_en) = 1;
-}
-
-
-/*************************************************************************/
-void USBHAL::configureDevice(void)
-{
- /*The pipes set up in USBHAL::realiseEndpoint*/
- /*usbx_function_clear_alt();*/ /* Alternate setting clear */
- /*usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);*/
-}
-
-
-/*************************************************************************/
-void USBHAL::unconfigureDevice(void)
-{
- /* The Interface would be managed by USBDevice */
- /*usbx_function_clear_alt();*/ /* Alternate setting clear */
- /*usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);*/
-}
-
-
-/*************************************************************************/
-void USBHAL::setAddress(uint8_t address)
-{
- if (address <= 127) {
- usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); /* OK */
- } else {
- usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); /* Not Spec */
- }
-}
-
-
-/*************************************************************************/
-bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags)
-{
- const struct PIPECFGREC *cfg;
- uint16_t pipe;
- uint16_t buf;
-
- if ( (EP0OUT == endpoint) || (EP0IN == endpoint) ) {
- return true;
- }
-
- for (cfg = &def_pipecfg[0]; cfg->pipesel != 0; cfg++) {
- if (cfg->endpoint == endpoint) {
- break;
- }
- }
- if (cfg->pipesel == 0) {
- return false;
- }
-
- pipe = ((cfg->pipesel & USB_PIPESEL_PIPESEL) >> USB_PIPESEL_PIPESEL_SHIFT);
-
- g_usbx_function_PipeTbl[ pipe ] = (uint16_t)(endpoint | ((cfg->pipesel & USB_FUNCTION_FIFO_USE) << 0));
-
- /* There are maintenance routine of SHTNAK and BFRE bits
- * in original sample program. This sample is not
- * programmed. Do maintenance the "def_pipecfg" array if
- * you want it. */
-
- /* Interrupt Disable */
- buf = USB20X.BRDYENB;
- buf &= (uint16_t)~g_usbx_function_bit_set[pipe];
- USB20X.BRDYENB = buf;
- buf = USB20X.NRDYENB;
- buf &= (uint16_t)~g_usbx_function_bit_set[pipe];
- USB20X.NRDYENB = buf;
- buf = USB20X.BEMPENB;
- buf &= (uint16_t)~g_usbx_function_bit_set[pipe];
- USB20X.BEMPENB = buf;
-
- usbx_function_set_pid_nak(pipe);
-
- /* CurrentPIPE Clear */
- if (RZA_IO_RegRead_16(&USB20X.CFIFOSEL, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE) == pipe) {
- RZA_IO_RegWrite_16(&USB20X.CFIFOSEL, 0, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE);
- }
-
- if (RZA_IO_RegRead_16(&USB20X.D0FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) {
- RZA_IO_RegWrite_16(&USB20X.D0FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE);
- }
-
- if (RZA_IO_RegRead_16(&USB20X.D1FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) {
- RZA_IO_RegWrite_16(&USB20X.D1FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE);
- }
-
- /* PIPE Configuration */
- USB20X.PIPESEL = pipe;
- USB20X.PIPECFG = cfg->pipecfg;
- USB20X.PIPEBUF = cfg->pipebuf;
- USB20X.PIPEMAXP = cfg->pipemaxp;
- USB20X.PIPEPERI = cfg->pipeperi;
-
- g_usbx_function_pipecfg[pipe] = cfg->pipecfg;
- g_usbx_function_pipebuf[pipe] = cfg->pipebuf;
- g_usbx_function_pipemaxp[pipe] = cfg->pipemaxp;
- g_usbx_function_pipeperi[pipe] = cfg->pipeperi;
-
- /* Buffer Clear */
- usbx_function_set_sqclr(pipe);
- usbx_function_aclrm(pipe);
-
- /* init Global */
- g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
- g_usbx_function_PipeDataSize[pipe] = 0;
-
- return true;
-}
-
-
-/*************************************************************************/
-// read setup packet
-void USBHAL::EP0setup(uint8_t *buffer)
-{
- memcpy(buffer, setup_buffer, MAX_PACKET_SIZE_EP0);
-}
-
-
-/*************************************************************************/
-void USBHAL::EP0readStage(void)
-{
- // No implements
-}
-
-
-/*************************************************************************/
-void USBHAL::EP0read(void)
-{
- uint8_t *buffer;
- uint32_t size;
-
- /* remain of last writing */
- while (EP0_read_status != DEVDRV_USBF_WRITEEND) {
- static uint8_t bbb[2] = { 255, 255 };
- EP0write(&bbb[0], 0);
- }
-
- buffer = (uint8_t*)(&setup_buffer[4]);
- size = (MAX_PACKET_SIZE_EP0 / 2) - 8;
- usbx_api_function_CtrlWriteStart(size, buffer);
-}
-
-
-/*************************************************************************/
-uint32_t USBHAL::EP0getReadResult(uint8_t *buffer)
-{
- memcpy(buffer, (uint8_t*)(&setup_buffer[4]), g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0]);
-
- return g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0];
-}
-
-
-/*************************************************************************/
-void USBHAL::EP0write(uint8_t *buffer, uint32_t size)
-{
- /* zero byte writing */
- if ( (size == 0) && (EP0_read_status == DEVDRV_USBF_WRITEEND) ) {
- return;
- }
-
- if (EP0_read_status == DEVDRV_USBF_WRITEEND) {
- /*1st block*/
- EP0_read_status = usbx_api_function_CtrlReadStart(size, buffer);
- } else {
- /* waits the last transmission */
- /*other blocks*/
- g_usbx_function_data_count[ USB_FUNCTION_PIPE0 ] = size;
- g_usbx_function_data_pointer [ USB_FUNCTION_PIPE0 ] = buffer;
- EP0_read_status = usbx_function_write_buffer_c(USB_FUNCTION_PIPE0);
- }
- /*max size may be deblocking outside*/
- if (size == MAX_PACKET_SIZE_EP0) {
- EP0_read_status = DEVDRV_USBF_WRITING;
- }
-}
-
-
-/*************************************************************************/
-#if 0 // No implements
-void USBHAL::EP0getWriteResult(void)
-{
-}
-#endif
-
-/*************************************************************************/
-void USBHAL::EP0stall(void)
-{
- stallEndpoint( 0 );
-}
-
-
-/*************************************************************************/
-EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t max_size)
-{
- uint32_t pipe = EP2PIPE(endpoint);
- uint32_t pipe_size;
- uint16_t pipe_status;
- EP_STATUS status = EP_COMPLETED;
-
- pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size);
-
- switch (pipe_status) {
- case DEVDRV_USBF_PIPE_IDLE:
- case DEVDRV_USBF_PIPE_WAIT:
- usbx_api_function_set_pid_nak(pipe);
- usbx_api_function_clear_pipe_status(pipe);
-
- usbx_api_function_start_receive_transfer(pipe, max_size, recv_buffer);
- break;
-
- default:
- status = EP_PENDING;
- break;
- }
-
- return status;
-}
-
-
-/*************************************************************************/
-EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t *buffer, uint32_t *bytes_read )
-{
- uint32_t pipe = EP2PIPE(endpoint);
- uint16_t pipe_status;
- uint16_t err;
- EP_STATUS status = EP_PENDING;
-
-
- if (EPx_read_status != DEVDRV_USBF_PIPE_WAIT) {
- return status;
- }
-
- pipe_status = usbx_api_function_check_pipe_status(pipe, bytes_read);
- switch (pipe_status) {
- case DEVDRV_USBF_PIPE_IDLE:
- return EP_COMPLETED;
-
- case DEVDRV_USBF_PIPE_DONE:
- return EP_COMPLETED;
-
- case DEVDRV_USBF_PIPE_WAIT:
- break;
-
- default:
- return status;
- }
-
- /* sets the output buffer and size */
- g_usbx_function_data_pointer[pipe] = buffer;
-
- /* receives data from pipe */
- err = usbx_function_read_buffer(pipe);
- recv_error = err;
- switch (err) {
- case USB_FUNCTION_READEND:
- case USB_FUNCTION_READSHRT:
- case USB_FUNCTION_READOVER:
- *bytes_read = g_usbx_function_PipeDataSize[pipe];
- break;
-
- case USB_FUNCTION_READING:
- case DEVDRV_USBF_FIFOERROR:
- break;
- }
-
- pipe_status = usbx_api_function_check_pipe_status(pipe, bytes_read);
- switch (pipe_status) {
- case DEVDRV_USBF_PIPE_DONE:
- status = EP_COMPLETED;
- break;
-
- case DEVDRV_USBF_PIPE_IDLE:
- case DEVDRV_USBF_PIPE_NORES:
- case DEVDRV_USBF_PIPE_STALL:
- case DEVDRV_USBF_FIFOERROR:
- default:
- break;
- }
-
- return status;
-}
-
-
-/*************************************************************************/
-EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size)
-{
- uint32_t pipe = EP2PIPE(endpoint);
- uint32_t pipe_size;
- uint16_t pipe_status;
- uint16_t err;
- uint16_t count;
- EP_STATUS status = EP_PENDING;
-
- pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size);
-
- /* waits the last transmission */
- count = 30000;
- while ((pipe_status == DEVDRV_USBF_PIPE_WAIT) || (pipe_status == DEVDRV_USBF_PIPE_DONE)) {
- pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size);
- if( --count == 0 ) {
- pipe_status = DEVDRV_USBF_PIPE_STALL;
- break;
- }
- }
-
- switch (pipe_status) {
- case DEVDRV_USBF_PIPE_IDLE:
- err = usbx_api_function_start_send_transfer(pipe, size, data);
-
- switch (err) {
- /* finish to write */
- case DEVDRV_USBF_WRITEEND:
- /* finish to write, but data is short */
- case DEVDRV_USBF_WRITESHRT:
- /* continue to write */
- case DEVDRV_USBF_WRITING:
- /* use DMA */
- case DEVDRV_USBF_WRITEDMA:
- /* error */
- case DEVDRV_USBF_FIFOERROR:
- status = EP_PENDING;
- break;
- }
- break;
-
- case DEVDRV_USBF_PIPE_WAIT:
- case DEVDRV_USBF_PIPE_DONE:
- status = EP_PENDING;
- break;
-
- case DEVDRV_USBF_PIPE_NORES:
- case DEVDRV_USBF_PIPE_STALL:
- default:
- status = EP_STALLED;
- break;
- }
-
- return status;
-}
-
-
-/*************************************************************************/
-EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint)
-{
- uint32_t pipe = EP2PIPE(endpoint);
- uint32_t pipe_size;
- uint16_t pipe_status;
- EP_STATUS status = EP_PENDING;
-
- pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size);
-
- switch (pipe_status) {
- case DEVDRV_USBF_PIPE_IDLE:
- status = EP_COMPLETED;
- break;
-
- case DEVDRV_USBF_PIPE_WAIT:
- status = EP_PENDING;
- break;
-
- case DEVDRV_USBF_PIPE_DONE:
- usbx_function_stop_transfer(pipe);
- status = EP_COMPLETED;
- break;
-
- case DEVDRV_USBF_PIPE_NORES:
- status = EP_STALLED;
- break;
-
- case DEVDRV_USBF_PIPE_STALL:
- status = EP_STALLED;
- break;
-
- default:
- status = EP_PENDING;
- }
-
- return status;
-}
-
-
-/*************************************************************************/
-void USBHAL::stallEndpoint(uint8_t endpoint)
-{
- uint32_t pipe = EP2PIPE(endpoint);
-
- usbx_function_clear_pid_stall(pipe);
-}
-
-
-/*************************************************************************/
-void USBHAL::unstallEndpoint(uint8_t endpoint)
-{
- uint32_t pipe = EP2PIPE(endpoint);
-
- usbx_function_set_pid_stall( pipe );
-}
-
-
-/*************************************************************************/
-bool USBHAL::getEndpointStallState(uint8_t endpoint)
-{
- // No implemens
- return false;
-}
-
-
-/*************************************************************************/
-#if 0 // No implements
-void USBHAL::remoteWakeup(void)
-{
-}
-#endif
-
-/*************************************************************************/
-void USBHAL::_usbisr(void)
-{
- instance->usbisr();
-}
-
-
-/*************************************************************************/
-void USBHAL::usbisr(void)
-{
- uint16_t int_sts0;
- uint16_t int_sts1;
- uint16_t int_sts2;
- uint16_t int_sts3;
- uint16_t int_enb0;
- uint16_t int_enb2;
- uint16_t int_enb3;
- uint16_t int_enb4;
- volatile uint16_t dumy_sts;
-
-
- int_sts0 = USB20X.INTSTS0;
-
- if (!(int_sts0 & (
- USB_FUNCTION_BITVBINT |
- USB_FUNCTION_BITRESM |
- USB_FUNCTION_BITSOFR |
- USB_FUNCTION_BITDVST |
- USB_FUNCTION_BITCTRT |
- USB_FUNCTION_BITBEMP |
- USB_FUNCTION_BITNRDY |
- USB_FUNCTION_BITBRDY ))) {
- return;
- }
-
- int_sts1 = USB20X.BRDYSTS;
- int_sts2 = USB20X.NRDYSTS;
- int_sts3 = USB20X.BEMPSTS;
- int_enb0 = USB20X.INTENB0;
- int_enb2 = USB20X.BRDYENB;
- int_enb3 = USB20X.NRDYENB;
- int_enb4 = USB20X.BEMPENB;
-
- if ((int_sts0 & USB_FUNCTION_BITRESM) &&
- (int_enb0 & USB_FUNCTION_BITRSME)) {
- USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITRESM;
- RZA_IO_RegWrite_16(&USB20X.INTENB0, 0, USB_INTENB0_RSME_SHIFT, USB_INTENB0_RSME);
- /*usbx_function_USB_FUNCTION_Resume();*/
- suspendStateChanged(1);
- } else if (
- (int_sts0 & USB_FUNCTION_BITVBINT) &&
- (int_enb0 & USB_FUNCTION_BITVBSE)) {
- USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVBINT;
-
- if (usbx_function_CheckVBUStaus() == DEVDRV_USBF_ON) {
- usbx_function_USB_FUNCTION_Attach();
- } else {
- usbx_function_USB_FUNCTION_Detach();
- }
- } else if (
- (int_sts0 & USB_FUNCTION_BITSOFR) &&
- (int_enb0 & USB_FUNCTION_BITSOFE)) {
- USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITSOFR;
- SOF((USB20X.FRMNUM & USB_FRMNUM_FRNM) >> USB_FRMNUM_FRNM_SHIFT);
- } else if (
- (int_sts0 & USB_FUNCTION_BITDVST) &&
- (int_enb0 & USB_FUNCTION_BITDVSE)) {
- USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITDVST;
- switch (int_sts0 & USB_FUNCTION_BITDVSQ) {
- case USB_FUNCTION_DS_POWR:
- break;
-
- case USB_FUNCTION_DS_DFLT:
- /*****************************************************************************
- * Function Name: usbx_function_USB_FUNCTION_BusReset
- * Description : This function is executed when the USB device is transitioned
- * : to POWERD_STATE. Sets the device descriptor according to the
- * : connection speed determined by the USB reset hand shake.
- * Arguments : none
- * Return Value : none
- *****************************************************************************/
- usbx_function_init_status(); /* memory clear */
-
-#if 0
- /* You would program those steps in USBCallback_busReset
- * if the system need the comment out steps.
- */
-
- if (usbx_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED) {
- /* Device Descriptor reset */
- usbx_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED);
- } else {
- /* Device Descriptor reset */
- usbx_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED);
- }
-#endif
- /* Default Control PIPE reset */
- /*****************************************************************************
- * Function Name: usbx_function_ResetDCP
- * Description : Initializes the default control pipe(DCP).
- * Outline : Reset default control pipe
- * Arguments : none
- * Return Value : none
- *****************************************************************************/
- USB20X.DCPCFG = 0;
- USB20X.DCPMAXP = 64; /*TODO: This value is copied from sample*/
-
- USB20X.CFIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
- USB20X.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
- USB20X.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
-
- busReset();
- break;
-
- case USB_FUNCTION_DS_ADDS:
- break;
-
- case USB_FUNCTION_DS_CNFG:
- break;
-
- case USB_FUNCTION_DS_SPD_POWR:
- case USB_FUNCTION_DS_SPD_DFLT:
- case USB_FUNCTION_DS_SPD_ADDR:
- case USB_FUNCTION_DS_SPD_CNFG:
- suspendStateChanged(0);
- /*usbx_function_USB_FUNCTION_Suspend();*/
- break;
-
- default:
- break;
- }
- } else if (
- (int_sts0 & USB_FUNCTION_BITBEMP) &&
- (int_enb0 & USB_FUNCTION_BITBEMP) &&
- ((int_sts3 & int_enb4) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) {
- /* ==== BEMP PIPE0 ==== */
- usbx_function_BEMPInterruptPIPE0(int_sts3, int_enb4, this, &USBHAL::EP0in);
- } else if (
- (int_sts0 & USB_FUNCTION_BITBRDY) &&
- (int_enb0 & USB_FUNCTION_BITBRDY) &&
- ((int_sts1 & int_enb2) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) {
- /* ==== BRDY PIPE0 ==== */
- usbx_function_BRDYInterruptPIPE0(int_sts1, int_enb2, this, &USBHAL::EP0out);
- } else if (
- (int_sts0 & USB_FUNCTION_BITNRDY) &&
- (int_enb0 & USB_FUNCTION_BITNRDY) &&
- ((int_sts2 & int_enb3) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) {
- /* ==== NRDY PIPE0 ==== */
- usbx_function_NRDYInterruptPIPE0(int_sts2, int_enb3, this, NULL);
- } else if (
- (int_sts0 & USB_FUNCTION_BITCTRT) && (int_enb0 & USB_FUNCTION_BITCTRE)) {
- int_sts0 = USB20X.INTSTS0;
- USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITCTRT;
-
- if (((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_RDDS) ||
- ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRDS) ||
- ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRND)) {
-
- /* remake EP0 into buffer */
- usbx_function_save_request();
- if ((USB20X.INTSTS0 & USB_FUNCTION_BITVALID) && (
- ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_RDDS) ||
- ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRDS) ||
- ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRND))) {
- /* New SETUP token received */
- /* Three dummy reads for cleearing interrupt requests */
- dumy_sts = USB20X.INTSTS0;
- dumy_sts = USB20X.INTSTS0;
- dumy_sts = USB20X.INTSTS0;
- return;
- }
- }
-
- switch (int_sts0 & USB_FUNCTION_BITCTSQ) {
- case USB_FUNCTION_CS_IDST:
- if (g_usbx_function_TestModeFlag == DEVDRV_USBF_YES) {
- /* ==== Test Mode ==== */
- usbx_function_USB_FUNCTION_TestMode();
- }
- /* Needs not procedure in this state */
- break;
-
- case USB_FUNCTION_CS_RDDS:
- /* Reads a setup packet */
- EP0setupCallback();
- break;
-
- case USB_FUNCTION_CS_WRDS:
- /* Original code was the SetDescriptor was called */
- EP0setupCallback();
- break;
-
- case USB_FUNCTION_CS_WRND:
- EP0setupCallback();
-
- /*The EP0setupCallback should finish in successful */
- usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);
-
- RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL);
- break;
-
- case USB_FUNCTION_CS_RDSS:
- RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL);
- break;
-
- case USB_FUNCTION_CS_WRSS:
- RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL);
- break;
-
- case USB_FUNCTION_CS_SQER:
- usbx_function_set_pid_stall(USB_FUNCTION_PIPE0);
- break;
-
- default:
- usbx_function_set_pid_stall(USB_FUNCTION_PIPE0);
- break;
- }
- } else if (
- (int_sts0 & USB_FUNCTION_BITBEMP) &&
- (int_enb0 & USB_FUNCTION_BITBEMP) &&
- (int_sts3 & int_enb4) ) {
- /* ==== BEMP PIPEx ==== */
- usbx_function_BEMPInterrupt(int_sts3, int_enb4, this, epCallback);
- } else if (
- (int_sts0 & USB_FUNCTION_BITBRDY) &&
- (int_enb0 & USB_FUNCTION_BITBRDY) &&
- (int_sts1 & int_enb2) ) {
- /* ==== BRDY PIPEx ==== */
- usbx_function_BRDYInterrupt(int_sts1, int_enb2, this, epCallback);
- } else if (
- (int_sts0 & USB_FUNCTION_BITNRDY) &&
- (int_enb0 & USB_FUNCTION_BITNRDY) &&
- (int_sts2 & int_enb3)) {
- /* ==== NRDY PIPEx ==== */
- usbx_function_NRDYInterrupt(int_sts2, int_enb3, this, epCallback);
- } else {
- /* Do Nothing */
- }
-
- /* Three dummy reads for cleearing interrupt requests */
- dumy_sts = USB20X.INTSTS0;
- dumy_sts = USB20X.INTSTS1;
-}
-
-/*************************************************************************/
-#endif
-/*************************************************************************/
-/*EOF*/
