USBDevice with MAX32620HSP platform support

Fork of USBDevice by mbed official

Files at this revision

API Documentation at this revision

Comitter:
mbed_official
Date:
Thu Nov 06 11:01:12 2014 +0000
Parent:
34:a4e9ddc2e2af
Child:
36:4d3e7f3d5211
Commit message:
Synchronized with git revision 8724eb616b6e07a3bd111d3022652eb5bbefe9b7

Full URL: https://github.com/mbedmicro/mbed/commit/8724eb616b6e07a3bd111d3022652eb5bbefe9b7/

[RZ/A1H] mbed-RZ first release

Changed in this revision

USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function_api.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function_dmacdrv.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_dataio.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_dma.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_intrn.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_lib.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_api.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_controlrw.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_global.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_sig.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_sub.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/rza_io_regrw.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/usb0_function_dmacdrv.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/usb0_function_userdef.c Show annotated file Show diff for this revision Revisions of this file
USBDevice/USBEndpoints.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/USBEndpoints_RZ_A1H.h Show annotated file Show diff for this revision Revisions of this file
USBDevice/USBHAL_RZ_A1H.cpp Show annotated file Show diff for this revision Revisions of this file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,367 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : devdrv_usb_function_api.h
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Description  : RZ/A1H R7S72100 USB Sample Program
+*******************************************************************************/
+#ifndef USB_FUNCTION_API_H
+#define USB_FUNCTION_API_H
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include <MBRZA1H.h>
+#include "r_typedefs.h"
+#include "usb0_function_api.h"
+#if 0
+#include "usb1_function_api.h"
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+typedef struct
+{
+    uint32_t fifo;
+    uint32_t buffer;
+    uint32_t bytes;
+    uint32_t dir;
+    uint32_t size;
+} USB_FUNCTION_DMA_t;
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+#define USBFCLOCK_X1_48MHZ                          (0x0000u)       /* USB_X1_48MHz */
+#define USBFCLOCK_EXTAL_12MHZ                       (0x0004u)       /* EXTAL_12MHz  */
+
+#define DEVDRV_USBF_ON                              (1)
+#define DEVDRV_USBF_OFF                             (0)
+#define DEVDRV_USBF_YES                             (1)
+#define DEVDRV_USBF_NO                              (0)
+
+#define DEVDRV_USBF_STALL                           (-2)
+
+#define DEVDRV_USBF_WRITEEND                        (0)
+#define DEVDRV_USBF_WRITESHRT                       (1)
+#define DEVDRV_USBF_WRITING                         (2)
+#define DEVDRV_USBF_WRITEDMA                        (3)
+
+#define DEVDRV_USBF_FIFOERROR                       (0xffff)
+
+#define DEVDRV_USBF_PIPE_IDLE                       (0x00)
+#define DEVDRV_USBF_PIPE_WAIT                       (0x01)
+#define DEVDRV_USBF_PIPE_DONE                       (0x02)
+#define DEVDRV_USBF_PIPE_NORES                      (0x03)
+#define DEVDRV_USBF_PIPE_STALL                      (0x04)
+
+#define DEVDRV_USBF_PID_NAK                         (0x0000u)
+#define DEVDRV_USBF_PID_BUF                         (0x0001u)
+#define DEVDRV_USBF_PID_STALL                       (0x0002u)
+#define DEVDRV_USBF_PID_STALL2                      (0x0003u)
+
+#define USB_FUNCTION_NON_SPEED                      (0)
+#define USB_FUNCTION_LOW_SPEED                      (1)
+#define USB_FUNCTION_FULL_SPEED                     (2)
+#define USB_FUNCTION_HIGH_SPEED                     (3)
+
+#define USB_FUNCTION_READEND                        (0)
+#define USB_FUNCTION_READSHRT                       (1)
+#define USB_FUNCTION_READING                        (2)
+#define USB_FUNCTION_READOVER                       (3)
+#define USB_FUNCTION_READZERO                       (4)
+
+#define USB_FUNCTION_MAX_PIPE_NO                    (15u)
+#define USB_FUNCTION_PIPE0                          (0)
+#define USB_FUNCTION_PIPE1                          (1)
+#define USB_FUNCTION_PIPE2                          (2)
+#define USB_FUNCTION_PIPE3                          (3)
+#define USB_FUNCTION_PIPE4                          (4)
+#define USB_FUNCTION_PIPE5                          (5)
+#define USB_FUNCTION_PIPE6                          (6)
+#define USB_FUNCTION_PIPE7                          (7)
+#define USB_FUNCTION_PIPE8                          (8)
+#define USB_FUNCTION_PIPE9                          (9)
+#define USB_FUNCTION_PIPEA                          (10)
+#define USB_FUNCTION_PIPEB                          (11)
+#define USB_FUNCTION_PIPEC                          (12)
+#define USB_FUNCTION_PIPED                          (13)
+#define USB_FUNCTION_PIPEE                          (14)
+#define USB_FUNCTION_PIPEF                          (15)
+
+#define USB_FUNCTION_ISO                            (0xc000u)
+#define USB_FUNCTION_INTERRUPT                      (0x8000u)
+#define USB_FUNCTION_BULK                           (0x4000u)
+
+#define USB_FUNCTION_NONE                           (0x0000u)
+#define USB_FUNCTON_BFREFIELD                       (0x0400u)
+#define USB_FUNCTION_BFREON                         (0x0400u)
+#define USB_FUNCTION_BFREOFF                        (0x0000u)
+#define USB_FUNCTION_DBLBFIELD                      (0x0200u)
+#define USB_FUNCTION_DBLBON                         (0x0200u)
+#define USB_FUNCTION_DBLBOFF                        (0x0000u)
+#define USB_FUNCTION_CNTMDFIELD                     (0x0100u)
+#define USB_FUNCTION_CNTMDON                        (0x0100u)
+#define USB_FUNCTION_CNTMDOFF                       (0x0000u)
+#define USB_FUNCTION_SHTNAKON                       (0x0080u)
+#define USB_FUNCTION_SHTNAKOFF                      (0x0000u)
+#define USB_FUNCTION_DIRFIELD                       (0x0010u)
+#define USB_FUNCTION_DIR_P_OUT                      (0x0000u)
+#define USB_FUNCTION_DIR_P_IN                       (0x0010u)
+#define USB_FUNCTION_EPNUMFIELD                     (0x000fu)
+#define USB_FUNCTION_MAX_EP_NO                      (15u)
+#define USB_FUNCTION_EP0                            (0u)
+#define USB_FUNCTION_EP1                            (1u)
+#define USB_FUNCTION_EP2                            (2u)
+#define USB_FUNCTION_EP3                            (3u)
+#define USB_FUNCTION_EP4                            (4u)
+#define USB_FUNCTION_EP5                            (5u)
+#define USB_FUNCTION_EP6                            (6u)
+#define USB_FUNCTION_EP7                            (7u)
+#define USB_FUNCTION_EP8                            (8u)
+#define USB_FUNCTION_EP9                            (9u)
+#define USB_FUNCTION_EP10                           (10u)
+#define USB_FUNCTION_EP11                           (11u)
+#define USB_FUNCTION_EP12                           (12u)
+#define USB_FUNCTION_EP13                           (13u)
+#define USB_FUNCTION_EP14                           (14u)
+#define USB_FUNCTION_EP15                           (15u)
+
+#define USB_FUNCTION_EPTABLE_LENGTH                 (5u)
+
+#define USB_FUNCTION_CUSE                           (0)
+#define USB_FUNCTION_D0USE                          (1)
+#define USB_FUNCTION_D0DMA                          (2)
+#define USB_FUNCTION_D1USE                          (3)
+#define USB_FUNCTION_D1DMA                          (4)
+
+#define USB_FUNCTION_CFIFO_USE                      (0x0000)
+#define USB_FUNCTION_D0FIFO_USE                     (0x1000)
+#define USB_FUNCTION_D1FIFO_USE                     (0x2000)
+#define USB_FUNCTION_D0FIFO_DMA                     (0x5000)
+#define USB_FUNCTION_D1FIFO_DMA                     (0x6000)
+
+#define USB_FUNCTION_BUF2FIFO                       (0)
+#define USB_FUNCTION_FIFO2BUF                       (1)
+
+#define USB_FUNCTION_DVST_POWERED                   (0x0001)
+#define USB_FUNCTION_DVST_DEFAULT                   (0x0002)
+#define USB_FUNCTION_DVST_ADDRESS                   (0x0003)
+#define USB_FUNCTION_DVST_CONFIGURED                (0x0004)
+#define USB_FUNCTION_DVST_SUSPEND                   (0x0005)
+#define USB_FUNCTION_DVST_CONFIGURED_SUSPEND        (0x0006)
+
+#define USB_FUNCTION_FUNCTION_TEST_SELECT           (0xff00u)
+#define USB_FUNCTION_FUNCTION_TEST_J                (0x0100u)
+#define USB_FUNCTION_FUNCTION_TEST_K                (0x0200u)
+#define USB_FUNCTION_FUNCTION_TEST_SE0_NAK          (0x0300u)
+#define USB_FUNCTION_FUNCTION_TEST_PACKET           (0x0400u)
+#define USB_FUNCTION_FUNCTION_TEST_FORCE_ENABLE     (0x0500u)
+#define USB_FUNCTION_FUNCTION_TEST_STSelectors      (0x0600u)
+#define USB_FUNCTION_FUNCTION_TEST_Reserved         (0x4000u)
+#define USB_FUNCTION_FUNCTION_TEST_VSTModes         (0xc000u)
+
+#define USB_FUNCTION_DT_TYPE                        (0xff00u)
+#define USB_FUNCTION_DT_INDEX                       (0xff)
+#define USB_FUNCTION_DT_DEVICE                      (0x01)
+#define USB_FUNCTION_DT_CONFIGURATION               (0x02)
+#define USB_FUNCTION_DT_STRING                      (0x03)
+#define USB_FUNCTION_DT_INTERFACE                   (0x04)
+#define USB_FUNCTION_DT_ENDPOINT                    (0x05)
+#define USB_FUNCTION_DT_DEVICE_QUALIFIER            (0x06)
+#define USB_FUNCTION_DT_OTHER_SPEED_CONFIGURATION   (0x07)
+#define USB_FUNCTION_DT_INTERFACE_POWER             (0x08)
+
+#define USB_FUNCTION_CF_RESERVED                    (0x80)
+#define USB_FUNCTION_CF_SELF                        (0x40)
+#define USB_FUNCTION_CF_RWUP                        (0x20)
+#define USB_FUNCTION_CF_NORWUP                      (0x00)
+#define USB_FUNCTION_EP_ERROR                       (0xff)
+
+#define USB_FUNCTION_EP_OUT                         (0x00)
+#define USB_FUNCTION_EP_IN                          (0x80)
+#define USB_FUNCTION_EP_CNTRL                       (0x00)
+#define USB_FUNCTION_EP_ISO                         (0x01)
+#define USB_FUNCTION_EP_BULK                        (0x02)
+#define USB_FUNCTION_EP_INT                         (0x03)
+
+#define USB_FUNCTION_STANDARD_REQUEST               (0x0000u)
+#define USB_FUNCTION_CLASS_REQUEST                  (0x0020u)
+#define USB_FUNCTION_VENDOR_REQUEST                 (0x0040u)
+#define USB_FUNCTION_DEVICE_REQUEST                 (0x0000u)
+#define USB_FUNCTION_INTERFACE_REQUEST              (0x0001u)
+#define USB_FUNCTION_ENDPOINT_REQUEST               (0x0002u)
+
+#define USB_FUNCTION_GETSTATUS_BUSPOWERD            (0x0000u)
+#define USB_FUNCTION_GETSTATUS_SELFPOWERD           (0x0001u)
+#define USB_FUNCTION_GETSTATUS_REMOTEWAKEUP         (0x0002u)
+#define USB_FUNCTION_GETSTATUS_NOTHALT              (0x0000u)
+#define USB_FUNCTION_GETSTATUS_HALT                 (0x0001u)
+
+#define USB_FUNCTION_FEATURE_ENDPOINT_HALT          (0x0000u)
+#define USB_FUNCTION_FEATURE_REMOTE_WAKEUP          (0x0001u)
+#define USB_FUNCTION_FEATURE_TEST_MODE              (0x0002u)
+
+#define USB_FUNCTION_bRequest                       (0xff00u)       /* b15-8:bRequest */
+#define USB_FUNCTION_bmRequestType                  (0x00ffu)       /* b7-0: bmRequestType */
+#define USB_FUNCTION_bmRequestTypeDir               (0x0080u)       /* b7  : Data transfer direction */
+#define USB_FUNCTION_bmRequestTypeType              (0x0060u)       /* b6-5: Type */
+#define USB_FUNCTION_bmRequestTypeRecip             (0x001fu)       /* b4-0: Recipient */
+
+
+/*******************************************************************************
+Variable Externs
+*******************************************************************************/
+
+
+/*******************************************************************************
+Functions Prototypes
+*******************************************************************************/
+#if 0
+void     R_USB_api_function_init(uint16_t root, uint8_t int_level, uint16_t mode, uint16_t clockmode);
+uint16_t R_USB_api_function_IsConfigured(uint16_t root);
+uint16_t R_USB_api_function_CtrlReadStart(uint16_t root, uint32_t size, uint8_t *data);
+void     R_USB_api_function_CtrlWriteStart(uint16_t root, uint32_t size, uint8_t *data);
+uint16_t R_USB_api_function_start_send_transfer(uint16_t root, uint16_t pipe, uint32_t size, uint8_t *data);
+uint16_t R_USB_api_function_check_pipe_status(uint16_t root, uint16_t pipe, uint32_t *size);
+void     R_USB_api_function_clear_pipe_status(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_start_receive_transfer(uint16_t root, uint16_t pipe, uint32_t size, uint8_t *data);
+void     R_USB_api_function_set_pid_buf(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_set_pid_nak(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_set_pid_stall(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_clear_pid_stall(uint16_t root, uint16_t pipe);
+uint16_t R_USB_api_function_get_pid(uint16_t root, uint16_t pipe);
+int32_t  R_USB_api_function_check_stall(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_set_sqclr(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_set_sqset(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_set_csclr(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_set_curpipe(uint16_t root, uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
+void     R_USB_api_function_clear_brdy_sts(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_clear_bemp_sts(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_clear_nrdy_sts(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_enable_brdy_int(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_disable_brdy_int(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_enable_bemp_int(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_disable_bemp_int(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_enable_nrdy_int(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_disable_nrdy_int(uint16_t root, uint16_t pipe);
+void     R_USB_api_function_stop_transfer(uint16_t root, uint16_t pipe);
+#endif
+
+#ifdef USB0_FUNCTION_API_H
+void     usb0_function_interrupt(uint32_t int_sense);
+void     usb0_function_dma_interrupt_d0fifo(uint32_t int_sense);
+void     usb0_function_dma_interrupt_d1fifo(uint32_t int_sense);
+
+void     usb0_function_Class0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Class1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Class2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Class3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Class4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Class5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Vendor0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Vendor1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Vendor2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Vendor3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Vendor4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Vendor5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_ResetDescriptor(uint16_t mode);
+
+IRQn_Type Userdef_USB_usb0_function_d0fifo_dmaintid(void);
+IRQn_Type Userdef_USB_usb0_function_d1fifo_dmaintid(void);
+void     Userdef_USB_usb0_function_attach(void);
+void     Userdef_USB_usb0_function_detach(void);
+void     Userdef_USB_usb0_function_delay_1ms(void);
+void     Userdef_USB_usb0_function_delay_xms(uint32_t msec);
+void     Userdef_USB_usb0_function_delay_10us(uint32_t usec);
+void     Userdef_USB_usb0_function_delay_500ns(void);
+void     Userdef_USB_usb0_function_start_dma(USB_FUNCTION_DMA_t *dma, uint16_t dfacc);
+uint32_t Userdef_USB_usb0_function_stop_dma0(void);
+uint32_t Userdef_USB_usb0_function_stop_dma1(void);
+
+void     usb0_function_stop_transfer(uint16_t pipe);
+void     usb0_function_enable_brdy_int(uint16_t pipe);
+void     usb0_function_disable_brdy_int(uint16_t pipe);
+void     usb0_function_enable_bemp_int(uint16_t pipe);
+void     usb0_function_disable_bemp_int(uint16_t pipe);
+void     usb0_function_enable_nrdy_int(uint16_t pipe);
+void     usb0_function_disable_nrdy_int(uint16_t pipe);
+#endif
+
+#ifdef  USB1_FUNCTION_API_H
+void     usb1_function_interrupt(uint32_t int_sense);
+void     usb1_function_dma_interrupt_d0fifo(uint32_t int_sense);
+void     usb1_function_dma_interrupt_d1fifo(uint32_t int_sense);
+
+void     usb1_function_Class0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Class1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Class2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Class3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Class4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Class5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Vendor0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Vendor1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Vendor2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Vendor3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Vendor4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_Vendor5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length);
+void     usb1_function_ResetDescriptor(uint16_t mode);
+
+uint16_t Userdef_USB_usb1_function_d0fifo_dmaintid(void);
+uint16_t Userdef_USB_usb1_function_d1fifo_dmaintid(void);
+void     Userdef_USB_usb1_function_attach(void);
+void     Userdef_USB_usb1_function_detach(void);
+void     Userdef_USB_usb1_function_delay_1ms(void);
+void     Userdef_USB_usb1_function_delay_xms(uint32_t msec);
+void     Userdef_USB_usb1_function_delay_10us(uint32_t usec);
+void     Userdef_USB_usb1_function_delay_500ns(void);
+void     Userdef_USB_usb1_function_start_dma(USB_FUNCTION_DMA_t *dma, uint16_t dfacc);
+uint32_t Userdef_USB_usb1_function_stop_dma0(void);
+uint32_t Userdef_USB_usb1_function_stop_dma1(void);
+
+void     usb1_function_stop_transfer(uint16_t pipe);
+void     usb1_function_enable_brdy_int(uint16_t pipe);
+void     usb1_function_disable_brdy_int(uint16_t pipe);
+void     usb1_function_enable_bemp_int(uint16_t pipe);
+void     usb1_function_disable_bemp_int(uint16_t pipe);
+void     usb1_function_enable_nrdy_int(uint16_t pipe);
+void     usb1_function_disable_nrdy_int(uint16_t pipe);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* USB_FUNCTION_API_H */
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,171 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function.h
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Description  : RZ/A1H R7S72100 USB Sample Program
+*******************************************************************************/
+#ifndef USB0_FUNCTION_H
+#define USB0_FUNCTION_H
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "devdrv_usb_function_api.h"
+#include "usb_function.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+extern const uint16_t       g_usb0_function_bit_set[];
+extern uint32_t             g_usb0_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1];
+extern uint8_t              *g_usb0_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1];
+
+extern uint16_t             g_usb0_function_PipeIgnore[];
+extern uint16_t             g_usb0_function_PipeTbl[];
+extern uint16_t             g_usb0_function_pipe_status[];
+extern uint32_t             g_usb0_function_PipeDataSize[];
+
+extern USB_FUNCTION_DMA_t   g_usb0_function_DmaInfo[];
+extern uint16_t             g_usb0_function_DmaPipe[];
+extern uint16_t             g_usb0_function_DmaBval[];
+extern uint16_t             g_usb0_function_DmaStatus[];
+
+extern uint16_t             g_usb0_function_CtrZeroLengthFlag;
+
+extern uint16_t             g_usb0_function_ConfigNum;
+extern uint16_t             g_usb0_function_Alternate[USB_FUNCTION_ALT_NO];
+extern uint16_t             g_usb0_function_RemoteWakeupFlag;
+extern uint16_t             g_usb0_function_TestModeFlag;
+extern uint16_t             g_usb0_function_TestModeSelectors;
+
+extern uint16_t             g_usb0_function_ReqType;
+extern uint16_t             g_usb0_function_ReqTypeType;
+extern uint16_t             g_usb0_function_ReqTypeRecip;
+extern uint16_t             g_usb0_function_ReqRequest;
+extern uint16_t             g_usb0_function_ReqValue;
+extern uint16_t             g_usb0_function_ReqIndex;
+extern uint16_t             g_usb0_function_ReqLength;
+
+extern uint16_t             g_usb0_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1];
+
+extern uint16_t             g_usb0_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1];
+extern uint16_t             g_usb0_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1];
+extern uint16_t             g_usb0_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1];
+extern uint16_t             g_usb0_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1];
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+/* ==== common ==== */
+void     usb0_function_dma_stop_d0(uint16_t pipe, uint32_t remain);
+void     usb0_function_dma_stop_d1(uint16_t pipe, uint32_t remain);
+uint16_t usb0_function_is_hispeed(void);
+uint16_t usb0_function_is_hispeed_enable(void);
+uint16_t usb0_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
+uint16_t usb0_function_write_buffer(uint16_t pipe);
+uint16_t usb0_function_write_buffer_c(uint16_t pipe);
+uint16_t usb0_function_write_buffer_d0(uint16_t pipe);
+uint16_t usb0_function_write_buffer_d1(uint16_t pipe);
+void     usb0_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
+uint16_t usb0_function_read_buffer(uint16_t pipe);
+uint16_t usb0_function_read_buffer_c(uint16_t pipe);
+uint16_t usb0_function_read_buffer_d0(uint16_t pipe);
+uint16_t usb0_function_read_buffer_d1(uint16_t pipe);
+uint16_t usb0_function_change_fifo_port(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
+void     usb0_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
+void     usb0_function_set_curpipe2(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc);
+uint16_t usb0_function_get_mbw(uint32_t trncount, uint32_t dtptr);
+uint16_t usb0_function_read_dma(uint16_t pipe);
+void     usb0_function_brdy_int(uint16_t status, uint16_t int_enb);
+void     usb0_function_nrdy_int(uint16_t status, uint16_t int_enb);
+void     usb0_function_bemp_int(uint16_t status, uint16_t int_enb);
+void     usb0_function_setting_interrupt(uint8_t level);
+void     usb0_function_reset_module(uint16_t clockmode);
+uint16_t usb0_function_get_buf_size(uint16_t pipe);
+uint16_t usb0_function_get_mxps(uint16_t pipe);
+void     usb0_function_clear_brdy_sts(uint16_t pipe);
+void     usb0_function_clear_bemp_sts(uint16_t pipe);
+void     usb0_function_clear_nrdy_sts(uint16_t pipe);
+void     usb0_function_set_pid_buf(uint16_t pipe);
+void     usb0_function_set_pid_nak(uint16_t pipe);
+void     usb0_function_set_pid_stall(uint16_t pipe);
+void     usb0_function_clear_pid_stall(uint16_t pipe);
+uint16_t usb0_function_get_pid(uint16_t pipe);
+void     usb0_function_set_sqclr(uint16_t pipe);
+void     usb0_function_set_sqset(uint16_t pipe);
+void     usb0_function_set_csclr(uint16_t pipe);
+void     usb0_function_aclrm(uint16_t pipe);
+void     usb0_function_set_aclrm(uint16_t pipe);
+void     usb0_function_clr_aclrm(uint16_t pipe);
+uint16_t usb0_function_get_sqmon(uint16_t pipe);
+uint16_t usb0_function_get_inbuf(uint16_t pipe);
+
+/* ==== function ==== */
+void     usb0_function_init_status(void);
+void     usb0_function_InitModule(uint16_t mode);
+uint16_t usb0_function_CheckVBUStaus(void);
+void     usb0_function_USB_FUNCTION_Attach(void);
+void     usb0_function_USB_FUNCTION_Detach(void);
+void     usb0_function_USB_FUNCTION_BusReset(void);
+void     usb0_function_USB_FUNCTION_Resume(void);
+void     usb0_function_USB_FUNCTION_Suspend(void);
+void     usb0_function_USB_FUNCTION_TestMode(void);
+void     usb0_function_ResetDCP(void);
+void     usb0_function_ResetEP(uint16_t num);
+uint16_t usb0_function_EpToPipe(uint16_t ep);
+void     usb0_function_InitEPTable(uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num);
+uint16_t usb0_function_GetConfigNum(void);
+uint16_t usb0_function_GetAltNum(uint16_t Con_Num, uint16_t Int_Num);
+uint16_t usb0_function_CheckRemoteWakeup(void);
+void     usb0_function_clear_alt(void);
+void     usb0_function_clear_pipe_tbl(void);
+void     usb0_function_clear_ep_table_index(void);
+uint16_t usb0_function_GetInterfaceNum(uint16_t num);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* USB0_FUNCTION_H */
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function_api.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,104 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_api.h
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Description  : RZ/A1H R7S72100 USB Sample Program
+*******************************************************************************/
+#ifndef USB0_FUNCTION_API_H
+#define USB0_FUNCTION_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Variable Externs
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+void     usb0_api_function_init(uint8_t int_level, uint16_t mode, uint16_t clockmode);
+uint16_t usb0_api_function_IsConfigured(void);
+uint16_t usb0_function_GetDeviceState(void);
+uint16_t usb0_api_function_CtrlReadStart(uint32_t size, uint8_t *data);
+void     usb0_api_function_CtrlWriteStart(uint32_t size, uint8_t *data);
+uint16_t usb0_api_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
+uint16_t usb0_api_function_check_pipe_status(uint16_t pipe, uint32_t *size);
+void     usb0_api_function_clear_pipe_status(uint16_t pipe);
+void     usb0_api_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
+void     usb0_api_function_set_pid_buf(uint16_t pipe);
+void     usb0_api_function_set_pid_nak(uint16_t pipe);
+void     usb0_api_function_set_pid_stall(uint16_t pipe);
+void     usb0_api_function_clear_pid_stall(uint16_t pipe);
+uint16_t usb0_api_function_get_pid(uint16_t pipe);
+int32_t  usb0_api_function_check_stall(uint16_t pipe);
+void     usb0_api_function_set_sqclr(uint16_t pipe);
+void     usb0_api_function_set_sqset(uint16_t pipe);
+void     usb0_api_function_set_csclr(uint16_t pipe);
+void     usb0_api_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
+void     usb0_api_function_clear_brdy_sts(uint16_t pipe);
+void     usb0_api_function_clear_bemp_sts(uint16_t pipe);
+void     usb0_api_function_clear_nrdy_sts(uint16_t pipe);
+
+void     usb0_function_ClearFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_SetFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_SetAddress(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_SetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_SetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_SetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_SynchFrame(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_GetStatus(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_GetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_GetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_GetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Resrv_0(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Resrv_123(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Resrv_4(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+void     usb0_function_Resrv_5(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* USB0_FUNCTION_API_H */
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function_dmacdrv.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,142 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_dmacdrv.h
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Description  : RZ/A1H R7S72100 USB Sample Program
+*******************************************************************************/
+#ifndef USB0_FUNCTION_DMACDRV_H
+#define USB0_FUNCTION_DMACDRV_H
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+typedef struct dmac_transinfo
+{
+    uint32_t src_addr;      /* Transfer source address                */
+    uint32_t dst_addr;      /* Transfer destination address           */
+    uint32_t count;         /* Transfer byte count                    */
+    uint32_t src_size;      /* Transfer source data size              */
+    uint32_t dst_size;      /* Transfer destination data size         */
+    uint32_t saddr_dir;     /* Transfer source address direction      */
+    uint32_t daddr_dir;     /* Transfer destination address direction */
+} dmac_transinfo_t;
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+/* ==== Transfer specification of the sample program ==== */
+#define DMAC_SAMPLE_SINGLE          (0)     /* Single transfer                   */
+#define DMAC_SAMPLE_CONTINUATION    (1)     /* Continuous transfer (use REN bit) */
+
+/* ==== DMA modes ==== */
+#define DMAC_MODE_REGISTER          (0)     /* Register mode */
+#define DMAC_MODE_LINK              (1)     /* Link mode     */
+
+/* ==== Transfer requests ==== */
+#define DMAC_REQ_MODE_EXT           (0)     /* External request                   */
+#define DMAC_REQ_MODE_PERI          (1)     /* On-chip peripheral module request  */
+#define DMAC_REQ_MODE_SOFT          (2)     /* Auto-request (request by software) */
+
+/* ==== DMAC transfer sizes ==== */
+#define DMAC_TRANS_SIZE_8           (0)     /* 8 bits    */
+#define DMAC_TRANS_SIZE_16          (1)     /* 16 bits   */
+#define DMAC_TRANS_SIZE_32          (2)     /* 32 bits   */
+#define DMAC_TRANS_SIZE_64          (3)     /* 64 bits   */
+#define DMAC_TRANS_SIZE_128         (4)     /* 128 bits  */
+#define DMAC_TRANS_SIZE_256         (5)     /* 256 bits  */
+#define DMAC_TRANS_SIZE_512         (6)     /* 512 bits  */
+#define DMAC_TRANS_SIZE_1024        (7)     /* 1024 bits */
+
+/* ==== Address increment for transferring ==== */
+#define DMAC_TRANS_ADR_NO_INC       (1)     /* Not increment */
+#define DMAC_TRANS_ADR_INC          (0)     /* Increment     */
+
+/* ==== Method for detecting DMA request ==== */
+#define DMAC_REQ_DET_FALL           (0)     /* Falling edge detection */
+#define DMAC_REQ_DET_RISE           (1)     /* Rising edge detection  */
+#define DMAC_REQ_DET_LOW            (2)     /* Low level detection    */
+#define DMAC_REQ_DET_HIGH           (3)     /* High level detection   */
+
+/* ==== Request Direction ==== */
+#define DMAC_REQ_DIR_SRC            (0)     /* DMAREQ is the source/ DMAACK is active when reading      */
+#define DMAC_REQ_DIR_DST            (1)     /* DMAREQ is the destination/ DMAACK is active when writing */
+
+/* ==== Descriptors ==== */
+#define DMAC_DESC_HEADER            (0)     /* Header              */
+#define DMAC_DESC_SRC_ADDR          (1)     /* Source Address      */
+#define DMAC_DESC_DST_ADDR          (2)     /* Destination Address */
+#define DMAC_DESC_COUNT             (3)     /* Transaction Byte    */
+#define DMAC_DESC_CHCFG             (4)     /* Channel Confg       */
+#define DMAC_DESC_CHITVL            (5)     /* Channel Interval    */
+#define DMAC_DESC_CHEXT             (6)     /* Channel Extension   */
+#define DMAC_DESC_LINK_ADDR         (7)     /* Link Address        */
+
+/* ==== On-chip peripheral module requests ===== */
+typedef enum dmac_request_factor
+{
+    DMAC_REQ_USB0_DMA0_TX,      /* USB_0 channel 0 transmit FIFO empty            */
+    DMAC_REQ_USB0_DMA0_RX,      /* USB_0 channel 0 receive FIFO full              */
+    DMAC_REQ_USB0_DMA1_TX,      /* USB_0 channel 1 transmit FIFO empty            */
+    DMAC_REQ_USB0_DMA1_RX,      /* USB_0 channel 1 receive FIFO full              */
+    DMAC_REQ_USB1_DMA0_TX,      /* USB_1 channel 0 transmit FIFO empty            */
+    DMAC_REQ_USB1_DMA0_RX,      /* USB_1 channel 0 receive FIFO full              */
+    DMAC_REQ_USB1_DMA1_TX,      /* USB_1 channel 1 transmit FIFO empty            */
+    DMAC_REQ_USB1_DMA1_RX,      /* USB_1 channel 1 receive FIFO full              */
+} dmac_request_factor_t;
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+void usb0_function_DMAC1_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation,
+                                        uint32_t request_factor, uint32_t req_direction);
+int32_t usb0_function_DMAC1_Open(uint32_t req);
+void usb0_function_DMAC1_Close(uint32_t *remain);
+void usb0_function_DMAC1_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count);
+
+void usb0_function_DMAC2_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation,
+                                        uint32_t request_factor, uint32_t req_direction);
+int32_t usb0_function_DMAC2_Open(uint32_t req);
+void usb0_function_DMAC2_Close(uint32_t *remain);
+void usb0_function_DMAC2_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* USB0_FUNCTION_DMACDRV_H */
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,143 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb_function.h
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Description  : RZ/A1H R7S72100 USB Sample Program
+*******************************************************************************/
+#ifndef USB_FUNCTION_H
+#define USB_FUNCTION_H
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "r_typedefs.h"
+#include "iodefine.h"
+#include "rza_io_regrw.h"
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+#define USB_FUNCTION_ALT_NO         (255)
+#define USB_FUNCTION_ALT_SET        (0xff)
+
+#define USB_FUNCTION_BITUPLLE       (0x0002u)
+#define USB_FUNCTION_BITUCKSEL      (0x0004u)
+#define USB_FUNCTION_BITBWAIT       (0x003fu)
+
+#define USB_FUNCTION_BUSWAIT_02     (0x0000u)
+#define USB_FUNCTION_BUSWAIT_03     (0x0001u)
+#define USB_FUNCTION_BUSWAIT_04     (0x0002u)
+#define USB_FUNCTION_BUSWAIT_05     (0x0003u)
+#define USB_FUNCTION_BUSWAIT_06     (0x0004u)
+#define USB_FUNCTION_BUSWAIT_07     (0x0005u)
+#define USB_FUNCTION_BUSWAIT_08     (0x0006u)
+#define USB_FUNCTION_BUSWAIT_09     (0x0007u)
+#define USB_FUNCTION_BUSWAIT_10     (0x0008u)
+#define USB_FUNCTION_BUSWAIT_11     (0x0009u)
+#define USB_FUNCTION_BUSWAIT_12     (0x000au)
+#define USB_FUNCTION_BUSWAIT_13     (0x000bu)
+#define USB_FUNCTION_BUSWAIT_14     (0x000cu)
+#define USB_FUNCTION_BUSWAIT_15     (0x000du)
+#define USB_FUNCTION_BUSWAIT_16     (0x000eu)
+#define USB_FUNCTION_BUSWAIT_17     (0x000fu)
+
+#define USB_FUNCTION_BITRESUME      (0x0020u)
+#define USB_FUNCTION_BITUACT        (0x0010u)
+#define USB_FUNCTION_HSPROC         (0x0004u)
+#define USB_FUNCTION_HSMODE         (0x0003u)
+#define USB_FUNCTION_FSMODE         (0x0002u)
+#define USB_FUNCTION_LSMODE         (0x0001u)
+#define USB_FUNCTION_UNDECID        (0x0000u)
+
+#define USB_FUNCTION_BITRCNT        (0x8000u)
+#define USB_FUNCTION_BITDREQE       (0x1000u)
+#define USB_FUNCTION_BITMBW         (0x0c00u)
+#define USB_FUNCTION_BITMBW_8       (0x0000u)
+#define USB_FUNCTION_BITMBW_16      (0x0400u)
+#define USB_FUNCTION_BITMBW_32      (0x0800u)
+#define USB_FUNCTION_BITBYTE_LITTLE (0x0000u)
+#define USB_FUNCTION_BITBYTE_BIG    (0x0100u)
+#define USB_FUNCTION_BITISEL        (0x0020u)
+#define USB_FUNCTION_BITCURPIPE     (0x000fu)
+
+#define USB_FUNCTION_CFIFO_READ     (0x0000u)
+#define USB_FUNCTION_CFIFO_WRITE    (0x0020u)
+
+#define USB_FUNCTION_BITBVAL        (0x8000u)
+#define USB_FUNCTION_BITBCLR        (0x4000u)
+#define USB_FUNCTION_BITFRDY        (0x2000u)
+#define USB_FUNCTION_BITDTLN        (0x0fffu)
+
+#define USB_FUNCTION_BITVBSE        (0x8000u)
+#define USB_FUNCTION_BITRSME        (0x4000u)
+#define USB_FUNCTION_BITSOFE        (0x2000u)
+#define USB_FUNCTION_BITDVSE        (0x1000u)
+#define USB_FUNCTION_BITCTRE        (0x0800u)
+#define USB_FUNCTION_BITVBINT       (0x8000u)
+#define USB_FUNCTION_BITRESM        (0x4000u)
+#define USB_FUNCTION_BITSOFR        (0x2000u)
+#define USB_FUNCTION_BITDVST        (0x1000u)
+#define USB_FUNCTION_BITCTRT        (0x0800u)
+
+#define USB_FUNCTION_BITBEMPE       (0x0400u)
+#define USB_FUNCTION_BITNRDYE       (0x0200u)
+#define USB_FUNCTION_BITBRDYE       (0x0100u)
+#define USB_FUNCTION_BITBEMP        (0x0400u)
+#define USB_FUNCTION_BITNRDY        (0x0200u)
+#define USB_FUNCTION_BITBRDY        (0x0100u)
+
+#define USB_FUNCTION_BITDVSQ        (0x0070u)
+#define USB_FUNCTION_BITDVSQS       (0x0030u)
+#define USB_FUNCTION_DS_SPD_CNFG    (0x0070u)
+#define USB_FUNCTION_DS_SPD_ADDR    (0x0060u)
+#define USB_FUNCTION_DS_SPD_DFLT    (0x0050u)
+#define USB_FUNCTION_DS_SPD_POWR    (0x0040u)
+#define USB_FUNCTION_DS_CNFG        (0x0030u)
+#define USB_FUNCTION_DS_ADDS        (0x0020u)
+#define USB_FUNCTION_DS_DFLT        (0x0010u)
+#define USB_FUNCTION_DS_POWR        (0x0000u)
+#define USB_FUNCTION_BITVALID       (0x0008u)
+#define USB_FUNCTION_BITCTSQ        (0x0007u)
+#define USB_FUNCTION_CS_SQER        (0x0006u)
+#define USB_FUNCTION_CS_WRND        (0x0005u)
+#define USB_FUNCTION_CS_WRSS        (0x0004u)
+#define USB_FUNCTION_CS_WRDS        (0x0003u)
+#define USB_FUNCTION_CS_RDSS        (0x0002u)
+#define USB_FUNCTION_CS_RDDS        (0x0001u)
+#define USB_FUNCTION_CS_IDST        (0x0000u)
+
+#define USB_FUNCTION_PIPExBUF       (64u)
+
+#define USB_FUNCTION_D0FIFO         (0)
+#define USB_FUNCTION_D1FIFO         (1)
+#define USB_FUNCTION_DMA_READY      (0)
+#define USB_FUNCTION_DMA_BUSY       (1)
+#define USB_FUNCTION_DMA_BUSYEND    (2)
+
+#define USB_FUNCTION_FIFO_USE       (0x7000)
+
+#endif /* USB_FUNCTION_FUNCTION_H */
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,32 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb_function_version.h
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Description  : RZ/A1H R7S72100 USB Sample Program
+*******************************************************************************/
+
+#define USB_FUNCTION_LOCAL_Rev  "VER080_140709"
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_dataio.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,2933 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_dataio.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+static uint16_t g_usb0_function_mbw[(USB_FUNCTION_MAX_PIPE_NO + 1)];
+
+static void     usb0_function_start_receive_trns_c(uint16_t pipe, uint32_t size, uint8_t *data);
+static void     usb0_function_start_receive_trns_d0(uint16_t pipe, uint32_t size, uint8_t *data);
+static void     usb0_function_start_receive_trns_d1(uint16_t pipe, uint32_t size, uint8_t *data);
+static void     usb0_function_start_receive_dma_d0(uint16_t pipe, uint32_t size, uint8_t *data);
+static void     usb0_function_start_receive_dma_d1(uint16_t pipe, uint32_t size, uint8_t *data);
+static uint16_t usb0_function_read_dma_d0(uint16_t pipe);
+static uint16_t usb0_function_read_dma_d1(uint16_t pipe);
+static uint16_t usb0_function_write_dma_d0(uint16_t pipe);
+static uint16_t usb0_function_write_dma_d1(uint16_t pipe);
+
+static void     usb0_function_read_c_fifo(uint16_t pipe, uint16_t count);
+static void     usb0_function_write_c_fifo(uint16_t Pipe, uint16_t count);
+static void     usb0_function_read_d0_fifo(uint16_t pipe, uint16_t count);
+static void     usb0_function_write_d0_fifo(uint16_t pipe, uint16_t count);
+static void     usb0_function_read_d1_fifo(uint16_t pipe, uint16_t count);
+static void     usb0_function_write_d1_fifo(uint16_t pipe, uint16_t count);
+
+static void     usb0_function_clear_transaction_counter(uint16_t pipe);
+static void     usb0_function_set_transaction_counter(uint16_t pipe, uint32_t count);
+
+static uint32_t usb0_function_com_get_dmasize(uint32_t trncount, uint32_t dtptr);
+
+static uint16_t usb0_function_set_dfacc_d0(uint16_t mbw, uint32_t count);
+static uint16_t usb0_function_set_dfacc_d1(uint16_t mbw, uint32_t count);
+
+
+/*******************************************************************************
+* Function Name: usb0_function_start_send_transfer
+* Description  : Starts the USB data communication using pipe specified by the argument.
+* Arguments    : uint16_t  pipe    ; Pipe Number
+*              : uint32_t size     ; Data Size
+*              : uint8_t  *data    ; Data Address
+* Return Value : DEVDRV_USBF_WRITEEND           ; Write end
+*              : DEVDRV_USBF_WRITESHRT          ; short data
+*              : DEVDRV_USBF_WRITING            ; Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           ; Write DMA
+*              : DEVDRV_USBF_FIFOERROR          ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t status;
+    uint16_t usefifo;
+    uint16_t mbw;
+
+    g_usb0_function_data_count[pipe]   = size;
+    g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
+
+    usb0_function_clear_bemp_sts(pipe);
+    usb0_function_clear_brdy_sts(pipe);
+    usb0_function_clear_nrdy_sts(pipe);
+
+    mbw = usb0_function_get_mbw(size, (uint32_t)data);
+
+    usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
+
+    switch (usefifo)
+    {
+        case USB_FUNCTION_D0FIFO_USE:
+        case USB_FUNCTION_D0FIFO_DMA:
+            usefifo = USB_FUNCTION_D0USE;
+        break;
+
+        case USB_FUNCTION_D1FIFO_USE:
+        case USB_FUNCTION_D1FIFO_DMA:
+            usefifo = USB_FUNCTION_D1USE;
+        break;
+
+        default:
+            usefifo = USB_FUNCTION_CUSE;
+        break;
+    };
+
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, usefifo, DEVDRV_USBF_NO, mbw);
+
+    usb0_function_clear_transaction_counter(pipe);
+
+    usb0_function_aclrm(pipe);
+
+    status = usb0_function_write_buffer(pipe);
+
+    if (status != DEVDRV_USBF_FIFOERROR)
+    {
+        usb0_function_set_pid_buf(pipe);
+    }
+
+    return status;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_buffer
+* Description  : Writes data in the buffer allocated in the pipe specified by
+*              : the argument. The FIFO for using is set in the pipe definition table.
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : DEVDRV_USBF_WRITEEND           ; Write end
+*              : DEVDRV_USBF_WRITESHRT          ; short data
+*              : DEVDRV_USBF_WRITING            ; Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           ; Write DMA
+*              : DEVDRV_USBF_FIFOERROR          ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_write_buffer (uint16_t pipe)
+{
+    uint16_t status;
+    uint16_t usefifo;
+
+    g_usb0_function_PipeIgnore[pipe] = 0;
+    usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
+
+    switch (usefifo)
+    {
+        case USB_FUNCTION_D0FIFO_USE:
+            status = usb0_function_write_buffer_d0(pipe);
+        break;
+
+        case USB_FUNCTION_D1FIFO_USE:
+            status = usb0_function_write_buffer_d1(pipe);
+        break;
+
+        case USB_FUNCTION_D0FIFO_DMA:
+            status = usb0_function_write_dma_d0(pipe);
+        break;
+
+        case USB_FUNCTION_D1FIFO_DMA:
+            status = usb0_function_write_dma_d1(pipe);
+        break;
+
+        default:
+            status = usb0_function_write_buffer_c(pipe);
+        break;
+    };
+
+    switch (status)
+    {
+        case DEVDRV_USBF_WRITING:                       /* Continue of data write */
+            usb0_function_enable_nrdy_int(pipe);        /* Error (NORES or STALL) */
+            usb0_function_enable_brdy_int(pipe);        /* Enable Ready Interrupt */
+        break;
+
+        case DEVDRV_USBF_WRITEEND:                      /* End of data write */
+        case DEVDRV_USBF_WRITESHRT:                     /* End of data write */
+            usb0_function_disable_brdy_int(pipe);       /* Disable Ready Interrupt */
+            usb0_function_clear_nrdy_sts(pipe);
+            usb0_function_enable_nrdy_int(pipe);        /* Error (NORES or STALL) */
+            /* for last transfer */
+            usb0_function_enable_bemp_int(pipe);        /* Enable Empty Interrupt */
+        break;
+
+        case DEVDRV_USBF_WRITEDMA:                      /* DMA write */
+            usb0_function_clear_nrdy_sts(pipe);
+            usb0_function_enable_nrdy_int(pipe);        /* Error (NORES or STALL) */
+        break;
+
+        case DEVDRV_USBF_FIFOERROR:                     /* FIFO access status */
+        default:
+            usb0_function_disable_brdy_int(pipe);       /* Disable Ready Interrupt */
+            usb0_function_disable_bemp_int(pipe);       /* Disable Empty Interrupt */
+            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
+        break;
+    }
+
+    return status;                      /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_buffer_c
+* Description  : Writes data in the buffer allocated in the pipe specified in
+*              : the argument. Writes data by CPU transfer using CFIFO.
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : DEVDRV_USBF_WRITEEND           ; Write end
+*              : DEVDRV_USBF_WRITESHRT          ; short data
+*              : DEVDRV_USBF_WRITING            ; Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           ; Write DMA
+*              : DEVDRV_USBF_FIFOERROR          ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_write_buffer_c (uint16_t pipe)
+{
+    uint32_t count;
+    uint16_t size;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+
+    if (g_usb0_function_CtrZeroLengthFlag == 1)
+    {
+        g_usb0_function_CtrZeroLengthFlag = 0;                  /* Zero Length Packet Flag CLR */
+        return DEVDRV_USBF_WRITEEND;
+    }
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    if (pipe == USB_FUNCTION_PIPE0)
+    {
+        buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw);
+    }
+    else
+    {
+        buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw);
+    }
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    size = usb0_function_get_buf_size(pipe);                    /* Data buffer size */
+    mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+    if (g_usb0_function_data_count[pipe] <= (uint32_t)size)
+    {
+        status = DEVDRV_USBF_WRITEEND;                          /* write continues */
+        count  = g_usb0_function_data_count[pipe];
+
+        if (count == 0)
+        {
+            status = DEVDRV_USBF_WRITESHRT;                     /* Null Packet is end of write */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = DEVDRV_USBF_WRITESHRT;                     /* Short Packet is end of write */
+        }
+    }
+    else
+    {
+        status = DEVDRV_USBF_WRITING;                           /* write continues */
+        count  = (uint32_t)size;
+    }
+
+    usb0_function_write_c_fifo(pipe, (uint16_t)count);
+
+    if (g_usb0_function_data_count[pipe] < (uint32_t)size)
+    {
+        g_usb0_function_data_count[pipe] = 0;
+
+        if (RZA_IO_RegRead_16(&USB200.CFIFOCTR, USB_CFIFOCTR_BVAL_SHIFT, USB_CFIFOCTR_BVAL) == 0)
+        {
+            USB200.CFIFOCTR = USB_FUNCTION_BITBVAL;             /* Short Packet */
+            g_usb0_function_CtrZeroLengthFlag = 1;              /* Zero Length Packet Flag */
+        }
+    }
+    else
+    {
+        g_usb0_function_data_count[pipe] -= count;
+    }
+
+    return status;                                              /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_buffer_d0
+* Description  : Writes data in the buffer allocated in the pipe specified in the argument.
+*              : Writes data by CPU transfer using D0FIFO.
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : DEVDRV_USBF_WRITEEND           ; Write end
+*              : DEVDRV_USBF_WRITESHRT          ; short data
+*              : DEVDRV_USBF_WRITING            ; Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           ; Write DMA
+*              : DEVDRV_USBF_FIFOERROR          ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_write_buffer_d0 (uint16_t pipe)
+{
+    uint32_t count;
+    uint16_t size;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+
+    mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
+    if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    size = usb0_function_get_buf_size(pipe);                    /* Data buffer size */
+    mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+    if (g_usb0_function_data_count[pipe] <= (uint32_t)size)
+    {
+        status = DEVDRV_USBF_WRITEEND;                          /* write continues */
+        count  = g_usb0_function_data_count[pipe];
+
+        if (count == 0)
+        {
+            status = DEVDRV_USBF_WRITESHRT;                     /* Null Packet is end of write */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = DEVDRV_USBF_WRITESHRT;                     /* Short Packet is end of write */
+        }
+    }
+    else
+    {
+        status = DEVDRV_USBF_WRITING;                           /* write continues */
+        count  = (uint32_t)size;
+    }
+
+    usb0_function_write_d0_fifo(pipe, (uint16_t)count);
+
+    if (g_usb0_function_data_count[pipe] < (uint32_t)size)
+    {
+        g_usb0_function_data_count[pipe] = 0;
+        if (RZA_IO_RegRead_16(&USB200.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
+        {
+            USB200.D0FIFOCTR = USB_FUNCTION_BITBVAL;            /* Short Packet */
+        }
+    }
+    else
+    {
+        g_usb0_function_data_count[pipe] -= count;
+    }
+
+    return status;                                              /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_buffer_d1
+* Description  : Writes data in the buffer allocated in the pipe specified in the argument.
+*              : Writes data by CPU transfer using D1FIFO.
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : DEVDRV_USBF_WRITEEND           ; Write end
+*              : DEVDRV_USBF_WRITESHRT          ; short data
+*              : DEVDRV_USBF_WRITING            ; Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           ; Write DMA
+*              : DEVDRV_USBF_FIFOERROR          ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_write_buffer_d1 (uint16_t pipe)
+{
+    uint32_t count;
+    uint16_t size;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    size = usb0_function_get_buf_size(pipe);                    /* Data buffer size */
+    mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+    if (g_usb0_function_data_count[pipe] <= (uint32_t)size)
+    {
+        status = DEVDRV_USBF_WRITEEND;                          /* write continues */
+        count  = g_usb0_function_data_count[pipe];
+
+        if (count == 0)
+        {
+            status = DEVDRV_USBF_WRITESHRT;                     /* Null Packet is end of write */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = DEVDRV_USBF_WRITESHRT;                     /* Short Packet is end of write */
+        }
+    }
+    else
+    {
+        status = DEVDRV_USBF_WRITING;                           /* write continues */
+        count  = (uint32_t)size;
+    }
+
+    usb0_function_write_d1_fifo(pipe, (uint16_t)count);
+
+    if (g_usb0_function_data_count[pipe] < (uint32_t)size)
+    {
+        g_usb0_function_data_count[pipe] = 0;
+
+        if (RZA_IO_RegRead_16(&USB200.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
+        {
+            USB200.D1FIFOCTR = USB_FUNCTION_BITBVAL;            /* Short Packet */
+        }
+    }
+    else
+    {
+        g_usb0_function_data_count[pipe] -= count;
+    }
+
+    return status;                                              /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_dma_d0
+* Description  : Writes data in the buffer allocated in the pipe specified in the argument.
+*              : Writes data by DMA transfer using D0FIFO.
+*              : The DMA-ch for using is specified by Userdef_USB_usb0_function_start_dma().
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : DEVDRV_USBF_WRITEEND           : Write end
+*              : DEVDRV_USBF_WRITESHRT          : short data
+*              : DEVDRV_USBF_WRITING            : Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           : Write DMA
+*              : DEVDRV_USBF_FIFOERROR          : FIFO status
+*******************************************************************************/
+static uint16_t usb0_function_write_dma_d0 (uint16_t pipe)
+{
+    uint32_t count;
+    uint16_t size;
+    uint16_t buffer;
+    uint16_t status;
+    uint16_t mbw;
+    uint16_t dfacc = 0;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw);
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                            /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    size  = usb0_function_get_buf_size(pipe);                       /* Data buffer size */
+    count = g_usb0_function_data_count[pipe];
+
+    if (count != 0)
+    {
+        g_usb0_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe;
+
+        if ((count % size) != 0)
+        {
+            g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 1;
+        }
+        else
+        {
+            g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 0;
+        }
+
+        dfacc = usb0_function_set_dfacc_d0(mbw, count);
+
+        if (mbw == USB_FUNCTION_BITMBW_32)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2;  /* 32bit transfer */
+        }
+        else if (mbw == USB_FUNCTION_BITMBW_16)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1;  /* 16bit transfer */
+        }
+        else
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0;  /* 8bit transfer */
+        }
+
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo   = USB_FUNCTION_D0FIFO_DMA;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].dir    = USB_FUNCTION_BUF2FIFO;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes  = count;
+
+        Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc);
+
+        usb0_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc);
+
+        RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
+
+        g_usb0_function_data_count[pipe]    = 0;
+        g_usb0_function_data_pointer[pipe] += count;
+        status = DEVDRV_USBF_WRITEDMA;                              /* DMA write  */
+    }
+    else
+    {
+        if (RZA_IO_RegRead_16(&USB200.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
+        {
+            RZA_IO_RegWrite_16(&USB200.D0FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */
+        }
+        status = DEVDRV_USBF_WRITESHRT;                             /* Short Packet is end of write */
+    }
+
+    return status;                                                  /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_dma_d1
+* Description  : Writes data in the buffer allocated in the pipe specified in the argument.
+*              : Writes data by DMA transfer using D1FIFO.
+*              : The DMA-ch for using is specified by Userdef_USB_usb0_function_start_dma().
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : DEVDRV_USBF_WRITEEND           : Write end
+*              : DEVDRV_USBF_WRITESHRT          : short data
+*              : DEVDRV_USBF_WRITING            : Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           : Write DMA
+*              : DEVDRV_USBF_FIFOERROR          : FIFO status
+*******************************************************************************/
+static uint16_t usb0_function_write_dma_d1 (uint16_t pipe)
+{
+    uint32_t count;
+    uint16_t size;
+    uint16_t buffer;
+    uint16_t status;
+    uint16_t mbw;
+    uint16_t dfacc=0;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw);
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                            /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    size  = usb0_function_get_buf_size(pipe);                       /* Data buffer size */
+    count = g_usb0_function_data_count[pipe];
+
+    if (count != 0)
+    {
+        g_usb0_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe;
+        if ((count % size) != 0)
+        {
+            g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 1;
+        }
+        else
+        {
+            g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 0;
+        }
+
+        dfacc = usb0_function_set_dfacc_d1(mbw, count);
+
+        if (mbw == USB_FUNCTION_BITMBW_32)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2;  /* 32bit transfer */
+        }
+        else if (mbw == USB_FUNCTION_BITMBW_16)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1;  /* 16bit transfer */
+        }
+        else
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0;  /* 8bit transfer */
+        }
+
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo   = USB_FUNCTION_D1FIFO_DMA;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].dir    = USB_FUNCTION_BUF2FIFO;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes  = count;
+
+        Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc);
+
+        usb0_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc);
+
+        RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
+
+        g_usb0_function_data_count[pipe]    = 0;
+        g_usb0_function_data_pointer[pipe] += count;
+
+        status = DEVDRV_USBF_WRITEDMA;                             /* DMA write  */
+    }
+    else
+    {
+        if (RZA_IO_RegRead_16(&USB200.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0)
+        {
+            RZA_IO_RegWrite_16(&USB200.D1FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */
+        }
+        status = DEVDRV_USBF_WRITESHRT;                             /* Short Packet is end of write */
+    }
+
+    return status;                                                  /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_start_receive_transfer
+* Description  : Starts USB data reception using the pipe specified in the argument.
+*              : The FIFO for using is set in the pipe definition table.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data Address
+* Return Value : none
+*******************************************************************************/
+void usb0_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t usefifo;
+
+    usb0_function_clear_bemp_sts(pipe);
+    usb0_function_clear_brdy_sts(pipe);
+    usb0_function_clear_nrdy_sts(pipe);
+
+    usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
+
+    switch (usefifo)
+    {
+        case USB_FUNCTION_D0FIFO_USE:
+            usb0_function_start_receive_trns_d0(pipe, size, data);
+        break;
+
+        case USB_FUNCTION_D1FIFO_USE:
+            usb0_function_start_receive_trns_d1(pipe, size, data);
+        break;
+
+        case USB_FUNCTION_D0FIFO_DMA:
+            usb0_function_start_receive_dma_d0(pipe, size, data);
+        break;
+
+        case USB_FUNCTION_D1FIFO_DMA:
+            usb0_function_start_receive_dma_d1(pipe, size, data);
+        break;
+
+        default:
+            usb0_function_start_receive_trns_c(pipe, size, data);
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_start_receive_trns_c
+* Description  : Reads data from the buffer allocated in the pipe specified in the argument.
+*              : Reads data by CPU transfer using CFIFO.
+*              : When storing data in the buffer allocated in the pipe specified in the
+*              : argument, BRDY interrupt is generated to read data
+*              : in the interrupt.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data Address
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_start_receive_trns_c (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(pipe);
+    g_usb0_function_data_count[pipe]   = size;
+    g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
+    g_usb0_function_PipeIgnore[pipe]   = 0;
+
+    g_usb0_function_PipeDataSize[pipe] = size;
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
+
+    mbw = usb0_function_get_mbw(size, (uint32_t)data);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw);
+    USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;
+
+    usb0_function_set_transaction_counter(pipe, size);
+
+    usb0_function_aclrm(pipe);
+
+    usb0_function_enable_nrdy_int(pipe);
+    usb0_function_enable_brdy_int(pipe);
+
+    usb0_function_set_pid_buf(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_start_receive_trns_d0
+* Description  : Reads data from the buffer allocated in the pipe specified in the argument.
+*              : Reads data by CPU transfer using D0FIFO.
+*              : This function does not read data from the buffer.
+*              : When storing data in the buffer allocated in the pipe specified
+*              : in the argument, BRDY interrupt is generated to read data in the
+*              : interrupt.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data Address
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_start_receive_trns_d0 (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(pipe);
+    g_usb0_function_data_count[pipe]   = size;
+    g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
+    g_usb0_function_PipeIgnore[pipe]   = 0;
+
+    g_usb0_function_PipeDataSize[pipe] = size;
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
+
+    mbw = usb0_function_get_mbw(size, (uint32_t)data);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
+
+    usb0_function_set_transaction_counter(pipe, size);
+
+    usb0_function_aclrm(pipe);
+
+    usb0_function_enable_nrdy_int(pipe);
+    usb0_function_enable_brdy_int(pipe);
+
+    usb0_function_set_pid_buf(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_start_receive_trns_d1
+* Description  : Reads data from the buffer allocated in the pipe specified in the argument.
+*              : Reads data by CPU transfer using D1FIFO.
+*              : This function does not read data from the buffer.
+*              : When storing data in the buffer allocated in the pipe specified
+*              : in the argument, BRDY interrupt is generated to read data.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data Address
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_start_receive_trns_d1 (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(pipe);
+    g_usb0_function_data_count[pipe]   = size;
+    g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
+    g_usb0_function_PipeIgnore[pipe]   = 0;
+
+    g_usb0_function_PipeDataSize[pipe] = size;
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
+
+    mbw = usb0_function_get_mbw(size, (uint32_t)data);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
+
+    usb0_function_set_transaction_counter(pipe, size);
+
+    usb0_function_aclrm(pipe);
+
+    usb0_function_enable_nrdy_int(pipe);
+    usb0_function_enable_brdy_int(pipe);
+
+    usb0_function_set_pid_buf(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_start_receive_dma_d0
+* Description  : Reads data from the buffer allocated in the pipe specified in the argument.
+*              : Reads data by DMA transfer using D0FIFO.
+*              : This function does not read data from the buffer.
+*              : When storing data in the buffer allocated in the pipe specified
+*              : in the argument, delivered read request to DMAC to read data from
+*              : the buffer by DMAC.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data Address
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_start_receive_dma_d0 (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(pipe);
+    g_usb0_function_data_count[pipe]   = size;
+    g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
+    g_usb0_function_PipeIgnore[pipe]   = 0;
+
+    g_usb0_function_PipeDataSize[pipe] = 0;
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
+
+    mbw = usb0_function_get_mbw(size, (uint32_t)data);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
+
+    usb0_function_set_transaction_counter(pipe, size);
+
+    usb0_function_aclrm(pipe);
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+    {
+        usb0_function_read_dma(pipe);
+
+        usb0_function_enable_nrdy_int(pipe);
+        usb0_function_enable_brdy_int(pipe);
+    }
+    else
+    {
+        usb0_function_enable_nrdy_int(pipe);
+        usb0_function_enable_brdy_int(pipe);
+    }
+
+    usb0_function_set_pid_buf(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_start_receive_dma_d1
+* Description  : Read data from the buffer allocated in the pipe specified in the argument.
+*              : Reads data by DMA transfer using D0FIFO.
+*              : This function does not read data from the buffer.
+*              : When storing data in the buffer allocated in the pipe specified
+*              : in the argument, delivered read request to DMAC to read data from
+*              : the buffer by DMAC.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data Address
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_start_receive_dma_d1 (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(pipe);
+    g_usb0_function_data_count[pipe]   = size;
+    g_usb0_function_data_pointer[pipe] = (uint8_t *)data;
+    g_usb0_function_PipeIgnore[pipe]   = 0;
+
+    g_usb0_function_PipeDataSize[pipe] = 0;
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_WAIT;
+
+    mbw = usb0_function_get_mbw(size, (uint32_t)data);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
+
+    usb0_function_set_transaction_counter(pipe, size);
+
+    usb0_function_aclrm(pipe);
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+    {
+        usb0_function_read_dma(pipe);
+
+        usb0_function_enable_nrdy_int(pipe);
+        usb0_function_enable_brdy_int(pipe);
+    }
+    else
+    {
+        usb0_function_enable_nrdy_int(pipe);
+        usb0_function_enable_brdy_int(pipe);
+    }
+
+    usb0_function_set_pid_buf(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_buffer
+* Description  : Reads data from the buffer allocated in the pipe specified
+*              : in the argument.
+*              : Uses FIF0 set in the pipe definition table.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_read_buffer (uint16_t pipe)
+{
+    uint16_t status;
+
+    g_usb0_function_PipeIgnore[pipe] = 0;
+
+    if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE)
+    {
+        status = usb0_function_read_buffer_d0(pipe);
+    }
+    else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE)
+    {
+        status = usb0_function_read_buffer_d1(pipe);
+    }
+    else
+    {
+        status = usb0_function_read_buffer_c(pipe);
+    }
+
+    switch (status)
+    {
+        case USB_FUNCTION_READING:                                      /* Continue of data read */
+        break;
+
+        case USB_FUNCTION_READEND:                                      /* End of data read */
+        case USB_FUNCTION_READSHRT:                                     /* End of data read */
+            usb0_function_disable_brdy_int(pipe);
+            g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
+            g_usb0_function_pipe_status[pipe]   = DEVDRV_USBF_PIPE_DONE;
+        break;
+
+        case USB_FUNCTION_READOVER:                                     /* buffer over */
+            if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE)
+            {
+                USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
+            }
+            else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE)
+            {
+                USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
+            }
+            else
+            {
+                USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;                 /* Clear BCLR */
+            }
+            usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
+            g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
+            g_usb0_function_pipe_status[pipe]   = DEVDRV_USBF_FIFOERROR;
+        break;
+
+        case DEVDRV_USBF_FIFOERROR:                                     /* FIFO access status */
+        default:
+            usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
+            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
+        break;
+    }
+
+    return status;                                                      /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_buffer_c
+* Description  : Reads data from the buffer allocated in the pipe specified in the argument.
+*              : Reads data by CPU transfer using CFIFO.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_read_buffer_c (uint16_t pipe)
+{
+    uint32_t count;
+    uint32_t dtln;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+
+    mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw);
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
+    mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+    if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
+    {
+        status = USB_FUNCTION_READOVER;
+        usb0_function_set_pid_nak(pipe);                        /* Set NAK */
+        count = g_usb0_function_data_count[pipe];
+    }
+    else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
+    {
+        status = USB_FUNCTION_READEND;
+        usb0_function_set_pid_nak(pipe);                        /* Set NAK */
+        count = dtln;
+
+        if (count == 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+        }
+    }
+    else                                                        /* continue Receive data */
+    {
+        status = USB_FUNCTION_READING;
+        count  = dtln;
+
+        if (count == 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            usb0_function_set_pid_nak(pipe);                    /* Set NAK */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            usb0_function_set_pid_nak(pipe);                    /* Set NAK */
+        }
+    }
+
+    if (count == 0)                                             /* 0 length packet */
+    {
+        USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;                 /* Clear BCLR */
+    }
+    else
+    {
+        usb0_function_read_c_fifo(pipe, (uint16_t)count);
+    }
+
+    g_usb0_function_data_count[pipe] -= count;
+
+    return status;                                              /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_buffer_d0
+* Description  : Reads data from the buffer allocated in the pipe specified in
+*              : the argument.
+*              : Reads data by CPU transfer using D0FIFO.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_read_buffer_d0 (uint16_t pipe)
+{
+    uint32_t count;
+    uint32_t dtln;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+    uint16_t pipebuf_size;
+
+    mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw);
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
+    mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+    if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
+    {
+        status = USB_FUNCTION_READOVER;
+        usb0_function_set_pid_nak(pipe);                        /* Set NAK */
+        count = g_usb0_function_data_count[pipe];
+    }
+    else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
+    {
+        status = USB_FUNCTION_READEND;
+        usb0_function_set_pid_nak(pipe);                        /* Set NAK */
+        count = dtln;
+
+        if (count == 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+        }
+    }
+    else                                                        /* continue Receive data */
+    {
+        status = USB_FUNCTION_READING;
+        count  = dtln;
+
+        if (count == 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            usb0_function_set_pid_nak(pipe);                    /* Set NAK */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            usb0_function_set_pid_nak(pipe);                    /* Set NAK */
+        }
+        else
+        {
+            pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
+
+            if (count != pipebuf_size)
+            {
+                status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
+                usb0_function_set_pid_nak(pipe);                /* Set NAK */
+            }
+        }
+    }
+
+    if (count == 0)                                             /* 0 length packet */
+    {
+        USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
+    }
+    else
+    {
+        usb0_function_read_d0_fifo(pipe, (uint16_t)count);
+    }
+
+    g_usb0_function_data_count[pipe] -= count;
+
+    return status;                                              /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_buffer_d1
+* Description  : Reads data from the buffer allocated in the pipe specified
+*              : in the argument.
+*              : Reads data by CPU transfer using D1FIFO.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_read_buffer_d1 (uint16_t pipe)
+{
+    uint32_t count;
+    uint32_t dtln;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+    uint16_t pipebuf_size;
+
+    mbw    = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+    buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw);
+
+    if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+    {
+        return DEVDRV_USBF_FIFOERROR;
+    }
+
+    dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
+    mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+    if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
+    {
+        status = USB_FUNCTION_READOVER;
+        usb0_function_set_pid_nak(pipe);                        /* Set NAK */
+        count = g_usb0_function_data_count[pipe];
+    }
+    else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
+    {
+        status = USB_FUNCTION_READEND;
+        usb0_function_set_pid_nak(pipe);                        /* Set NAK */
+        count = dtln;
+        if (count == 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+        }
+    }
+    else                                                        /* continue Receive data */
+    {
+        status = USB_FUNCTION_READING;
+        count  = dtln;
+        if (count == 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            usb0_function_set_pid_nak(pipe);                    /* Set NAK */
+        }
+
+        if ((count % mxps) != 0)
+        {
+            status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            usb0_function_set_pid_nak(pipe);                    /* Set NAK */
+        }
+        else
+        {
+            pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
+
+            if (count != pipebuf_size)
+            {
+                status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
+                usb0_function_set_pid_nak(pipe);                /* Set NAK */
+            }
+        }
+    }
+
+    if (count == 0)                                             /* 0 length packet */
+    {
+        USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
+    }
+    else
+    {
+        usb0_function_read_d1_fifo(pipe, (uint16_t)count);
+    }
+
+    g_usb0_function_data_count[pipe] -= count;
+
+    return status;                                              /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_dma
+* Description  : Reads data from the buffer allocated in the pipe specified
+*              : in the argument.
+*              : Reads data by DMA transfer using D0FIFO or D1FIFO.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+uint16_t usb0_function_read_dma (uint16_t pipe)
+{
+    uint16_t status;
+
+    g_usb0_function_PipeIgnore[pipe] = 0;
+    if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA)
+    {
+        status = usb0_function_read_dma_d0(pipe);
+    }
+    else
+    {
+        status = usb0_function_read_dma_d1(pipe);
+    }
+
+    switch (status)
+    {
+        case USB_FUNCTION_READING:                                      /* Continue of data read */
+        break;
+
+        case USB_FUNCTION_READZERO:                                     /* End of data read */
+            usb0_function_disable_brdy_int(pipe);
+            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
+        break;
+
+        case USB_FUNCTION_READEND:                                      /* End of data read */
+        case USB_FUNCTION_READSHRT:                                     /* End of data read */
+            usb0_function_disable_brdy_int(pipe);
+
+            if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+            {
+                g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
+            }
+        break;
+
+        case USB_FUNCTION_READOVER:                                     /* buffer over */
+            usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
+
+            if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+            {
+                g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe];
+            }
+            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
+        break;
+
+        case DEVDRV_USBF_FIFOERROR:                                     /* FIFO access status */
+        default:
+            usb0_function_disable_brdy_int(pipe);                       /* Disable Ready Interrupt */
+            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR;
+        break;
+    }
+
+    return status;                                                      /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_dma_d0
+* Description  : Writes data in the buffer allocated in the pipe specified
+*              : in the argument.
+*              : Reads data by DMA transfer using D0FIFO.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READZERO         ; zero data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+static uint16_t usb0_function_read_dma_d0 (uint16_t pipe)
+{
+    uint32_t count;
+    uint32_t dtln;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+    uint16_t dfacc = 0;
+    uint16_t pipebuf_size;
+
+    g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+    {
+        count  = g_usb0_function_data_count[pipe];
+        status = USB_FUNCTION_READING;
+    }
+    else
+    {
+        buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw);
+
+        if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+        {
+            return DEVDRV_USBF_FIFOERROR;
+        }
+
+        dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
+        mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+        if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
+        {
+            status = USB_FUNCTION_READOVER;
+            count  = g_usb0_function_data_count[pipe];
+        }
+        else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
+        {
+            status = USB_FUNCTION_READEND;
+            count  = dtln;
+            if (count == 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            }
+
+            if ((count % mxps) != 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            }
+        }
+        else                                                        /* continue Receive data */
+        {
+            status = USB_FUNCTION_READING;
+            count  = dtln;
+
+            if (count == 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            }
+
+            if ((count % mxps) != 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            }
+            else
+            {
+                pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
+                if (count != pipebuf_size)
+                {
+                    status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
+                }
+            }
+        }
+    }
+
+    if (count == 0)                                                 /* 0 length packet */
+    {
+        if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+        {
+            USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
+            status = USB_FUNCTION_READZERO;                         /* Null Packet receive */
+        }
+        else
+        {
+            usb0_function_set_curpipe(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw);
+                                                                    /* transaction counter No set */
+                                                                    /* FRDY = 1, DTLN = 0 -> BRDY */
+        }
+    }
+    else
+    {
+        dfacc = usb0_function_set_dfacc_d0(mbw, count);
+
+        if (mbw == USB_FUNCTION_BITMBW_32)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2;  /* 32bit transfer */
+        }
+        else if (mbw == USB_FUNCTION_BITMBW_16)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1;  /* 16bit transfer */
+        }
+        else
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0;  /* 8bit transfer */
+        }
+
+        g_usb0_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe;        /* not use in read operation */
+        g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 0;           /* not use in read operation */
+
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo   = USB_FUNCTION_D0FIFO_DMA;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].dir    = USB_FUNCTION_FIFO2BUF;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
+        g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes  = count;
+
+        if (status == USB_FUNCTION_READING)
+        {
+            g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSY;
+        }
+        else
+        {
+            g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSYEND;
+        }
+
+        Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc);
+
+        usb0_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc);
+
+        RZA_IO_RegWrite_16(&USB200.D0FIFOSEL,
+                            1,
+                            USB_DnFIFOSEL_DREQE_SHIFT,
+                            USB_DnFIFOSEL_DREQE);
+    }
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+    {
+        g_usb0_function_data_count[pipe]   -= count;
+        g_usb0_function_data_pointer[pipe] += count;
+        g_usb0_function_PipeDataSize[pipe] += count;
+    }
+
+    return status;                                                  /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_dma_d1
+* Description  : Reads data from the buffer allocated in the pipe specified in
+*              : the argument.
+*              : Reads data by DMA transfer using D1FIFO.
+* Arguments    : uint16_t pipe     ; Pipe Number
+* Return Value : USB_FUNCTION_READEND          ; Read end
+*              : USB_FUNCTION_READSHRT         ; short data
+*              : USB_FUNCTION_READZERO         ; zero data
+*              : USB_FUNCTION_READING          ; Continue of data read
+*              : USB_FUNCTION_READOVER         ; buffer over
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO status
+*******************************************************************************/
+static uint16_t usb0_function_read_dma_d1 (uint16_t pipe)
+{
+    uint32_t count;
+    uint32_t dtln;
+    uint16_t buffer;
+    uint16_t mxps;
+    uint16_t status;
+    uint16_t mbw;
+    uint16_t dfacc=0;
+    uint16_t pipebuf_size;
+
+    g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]);
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+    {
+        count  = g_usb0_function_data_count[pipe];
+        status = USB_FUNCTION_READING;
+    }
+    else
+    {
+        buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw);
+        if (buffer == DEVDRV_USBF_FIFOERROR)                        /* FIFO access status */
+        {
+            return DEVDRV_USBF_FIFOERROR;
+        }
+
+        dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN);
+        mxps = usb0_function_get_mxps(pipe);                        /* Max Packet Size */
+
+        if (g_usb0_function_data_count[pipe] < dtln)                /* Buffer Over ? */
+        {
+            status = USB_FUNCTION_READOVER;
+            count  = g_usb0_function_data_count[pipe];
+        }
+        else if (g_usb0_function_data_count[pipe] == dtln)          /* just Receive Size */
+        {
+            status = USB_FUNCTION_READEND;
+            count  = dtln;
+            if (count == 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            }
+
+            if ((count % mxps) != 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            }
+        }
+        else                                                        /* continue Receive data */
+        {
+            status = USB_FUNCTION_READING;
+            count  = dtln;
+            if (count == 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Null Packet receive */
+            }
+
+            if ((count % mxps) != 0)
+            {
+                status = USB_FUNCTION_READSHRT;                     /* Short Packet receive */
+            }
+            else
+            {
+                pipebuf_size = usb0_function_get_buf_size(pipe);    /* Data buffer size */
+                if (count != pipebuf_size)
+                {
+                    status = USB_FUNCTION_READSHRT;                 /* Short Packet receive */
+                }
+            }
+        }
+    }
+
+    if (count == 0)                                                 /* 0 length packet */
+    {
+        if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+        {
+            USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;                /* Clear BCLR */
+            status = USB_FUNCTION_READZERO;                         /* Null Packet receive */
+        }
+        else
+        {
+            usb0_function_set_curpipe(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw);
+                                                                    /* transaction counter No set */
+                                                                    /* FRDY = 1, DTLN = 0 -> BRDY */
+        }
+    }
+    else
+    {
+        dfacc = usb0_function_set_dfacc_d1(mbw, count);
+
+        if (mbw == USB_FUNCTION_BITMBW_32)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2;  /* 32bit transfer */
+        }
+        else if (mbw == USB_FUNCTION_BITMBW_16)
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1;  /* 16bit transfer */
+        }
+        else
+        {
+            g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0;  /* 8bit transfer */
+        }
+
+        g_usb0_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe;        /* not use in read operation */
+        g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 0;           /* not use in read operation */
+
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo   = USB_FUNCTION_D1FIFO_DMA;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].dir    = USB_FUNCTION_FIFO2BUF;
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe];
+        g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes  = count;
+
+        if (status == USB_FUNCTION_READING)
+        {
+            g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSY;
+        }
+        else
+        {
+            g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSYEND;
+        }
+
+        Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc);
+
+        usb0_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc);
+
+        RZA_IO_RegWrite_16(&USB200.D1FIFOSEL,
+                            1,
+                            USB_DnFIFOSEL_DREQE_SHIFT,
+                            USB_DnFIFOSEL_DREQE);
+    }
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+    {
+        g_usb0_function_data_count[pipe]   -= count;
+        g_usb0_function_data_pointer[pipe] += count;
+        g_usb0_function_PipeDataSize[pipe] += count;
+    }
+
+    return status;                                                  /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_change_fifo_port
+* Description  : Allocates FIF0 specified by the argument in the pipe assigned
+*              : by the argument. After allocating FIF0, waits in the software
+*              : till the corresponding pipe becomes ready.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t fifosel   ; Select FIFO
+*              : uint16_t isel      ; FIFO Access Direction
+*              : uint16_t mbw       ; FIFO Port Access Bit Width
+* Return Value : DEVDRV_USBF_FIFOERROR         ; Error
+*              : Others            ; CFIFOCTR/D0FIFOCTR/D1FIFOCTR Register Value
+*******************************************************************************/
+uint16_t usb0_function_change_fifo_port (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw)
+{
+    uint16_t buffer;
+    uint32_t loop;
+    volatile uint32_t loop2;
+
+    usb0_function_set_curpipe(pipe, fifosel, isel, mbw);
+
+    for (loop = 0; loop < 4; loop++)
+    {
+        switch (fifosel)
+        {
+            case USB_FUNCTION_CUSE:
+                buffer = USB200.CFIFOCTR;
+            break;
+
+            case USB_FUNCTION_D0USE:
+            case USB_FUNCTION_D0DMA:
+                buffer = USB200.D0FIFOCTR;
+            break;
+
+            case USB_FUNCTION_D1USE:
+            case USB_FUNCTION_D1DMA:
+                buffer = USB200.D1FIFOCTR;
+            break;
+
+            default:
+                buffer = 0;
+            break;
+        }
+
+        if ((buffer & USB_FUNCTION_BITFRDY) == USB_FUNCTION_BITFRDY)
+        {
+            return buffer;
+        }
+
+        loop2 = 25;
+        while (loop2-- > 0)
+        {
+            /* wait */
+        }
+    }
+
+    return DEVDRV_USBF_FIFOERROR;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_curpipe
+* Description  : Allocates FIF0 specified by the argument in the pipe assigned
+*              : by the argument.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t fifosel   ; Select FIFO
+*              : uint16_t isel      ; FIFO Access Direction
+*              : uint16_t mbw       ; FIFO Port Access Bit Width
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw)
+{
+    uint16_t buffer;
+    uint32_t loop;
+    volatile uint32_t loop2;
+
+    g_usb0_function_mbw[pipe] = mbw;
+
+    switch (fifosel)
+    {
+        case USB_FUNCTION_CUSE:
+            buffer  = USB200.CFIFOSEL;
+            buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE);
+            buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL);
+            USB200.CFIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
+                        (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+            buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+            buffer |= (uint16_t)(isel | pipe | mbw);
+            USB200.CFIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
+                        (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+        break;
+
+        case USB_FUNCTION_D0DMA:
+        case USB_FUNCTION_D0USE:
+            buffer  = USB200.D0FIFOSEL;
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
+            USB200.D0FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
+                        (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+            buffer |= (uint16_t)(pipe | mbw);
+            USB200.D0FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
+                        (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+        break;
+
+        case USB_FUNCTION_D1DMA:
+        case USB_FUNCTION_D1USE:
+            buffer  = USB200.D1FIFOSEL;
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
+            USB200.D1FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
+                        (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+            buffer |= (uint16_t)(pipe | mbw);
+            USB200.D1FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) ==
+                        (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+        break;
+
+        default:
+        break;
+    }
+
+    /* Cautions !!!
+     * Depending on the external bus speed of CPU, you may need to wait for 450ns here.
+     * For details, please look at the data sheet.   */
+    loop2 = 100;
+
+    while (loop2-- > 0)
+    {
+        /* wait */
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_curpipe2
+* Description  : Allocates FIF0 specified by the argument in the pipe assigned
+*              : by the argument.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t fifosel   ; Select FIFO
+*              : uint16_t isel      ; FIFO Access Direction
+*              : uint16_t mbw       ; FIFO Port Access Bit Width
+*              : uint16_t dfacc     ; DFACC Access mode
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_curpipe2 (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc)
+{
+    uint16_t buffer;
+    uint32_t loop;
+#ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
+    uint32_t dummy;
+#endif
+    volatile uint32_t loop2;
+
+    g_usb0_function_mbw[pipe] = mbw;
+
+    switch (fifosel)
+    {
+        case USB_FUNCTION_CUSE:
+            buffer  = USB200.CFIFOSEL;
+            buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE);
+            buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL);
+            USB200.CFIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
+                        (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+            buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+            buffer |= (uint16_t)(isel | pipe | mbw);
+            USB200.CFIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) ==
+                        (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+        break;
+
+        case USB_FUNCTION_D0DMA:
+        case USB_FUNCTION_D0USE:
+            buffer  = USB200.D0FIFOSEL;
+#ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+
+            if (dfacc != 0)
+            {
+                buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32);
+            }
+#else
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
+#endif
+            USB200.D0FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+
+#ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
+            if (dfacc != 0)
+            {
+                dummy = USB200.D0FIFO.UINT32;
+            }
+#endif
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+            buffer |= (uint16_t)(pipe | mbw);
+            USB200.D0FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+        break;
+
+        case USB_FUNCTION_D1DMA:
+        case USB_FUNCTION_D1USE:
+            buffer  = USB200.D1FIFOSEL;
+#ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+
+            if (dfacc != 0)
+            {
+                buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32);
+            }
+#else
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE);
+#endif
+            USB200.D1FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+#ifdef  __USB_FUNCTION_DF_ACC_ENABLE__
+            if (dfacc != 0)
+            {
+                dummy = USB200.D1FIFO.UINT32;
+                loop = dummy;                   // avoid warning.
+            }
+#endif
+            buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW);
+            buffer |= (uint16_t)(pipe | mbw);
+            USB200.D1FIFOSEL = buffer;
+
+            for (loop = 0; loop < 4; loop++)
+            {
+                if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE))
+                {
+                    break;
+                }
+
+                loop2 = 100;
+
+                while (loop2-- > 0)
+                {
+                    /* wait */
+                }
+            }
+        break;
+
+        default:
+        break;
+    }
+
+    /* Cautions !!!
+     * Depending on the external bus speed of CPU, you may need to wait for 450ns here.
+     * For details, please look at the data sheet.   */
+    loop2 = 100;
+
+    while (loop2-- > 0)
+    {
+        /* wait */
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_c_fifo
+* Description  : Writes data in CFIFO.
+*              : Writes data by BYTE/WORD/LONG according to access size
+*              : to the pipe specified by the arguments.
+*              : Before executing this function, allocating CFIF0 in the specified pipe
+*              : should be completed.
+*              : Before executing this function, access size to the specified pipe
+*              : should be fixed and set in g_usb0_function_mbw[].
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t count     ; Data Size(Byte)
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_write_c_fifo (uint16_t pipe, uint16_t count)
+{
+    uint16_t even;
+
+    if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
+    {
+        for (even = count; even; --even)
+        {
+            USB200.CFIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe];
+            g_usb0_function_data_pointer[pipe] += 1;
+        }
+    }
+    else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
+    {
+        for (even = (uint16_t)(count / 2); even; --even)
+        {
+            USB200.CFIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]);
+            g_usb0_function_data_pointer[pipe] += 2;
+        }
+    }
+    else
+    {
+        for (even = (uint16_t)(count / 4); even; --even)
+        {
+            USB200.CFIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]);
+            g_usb0_function_data_pointer[pipe] += 4;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_c_fifo
+* Description  : Reads data from CFIFO.
+*              : Reads data by BYTE/WORD/LONG according to access size
+*              : to the pipe specified by the arguments.
+*              : Before executing this function, allocating CFIF0 in the specified pipe
+*              : should be completed.
+*              : Before executing this function, access size to the specified pipe
+*              : should be fixed and set in g_usb0_function_mbw[].
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t count     ; Data Size(Byte)
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_read_c_fifo (uint16_t pipe, uint16_t count)
+{
+    uint16_t even;
+
+    if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
+    {
+        for (even = count; even; --even)
+        {
+            *g_usb0_function_data_pointer[pipe] = USB200.CFIFO.UINT8[HH];
+            g_usb0_function_data_pointer[pipe] += 1;
+        }
+    }
+    else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
+    {
+        for (even = (uint16_t)((count + 1) / 2); even; --even)
+        {
+            *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.CFIFO.UINT16[H];
+            g_usb0_function_data_pointer[pipe] += 2;
+        }
+    }
+    else
+    {
+        for (even = (uint16_t)((count + 3) / 4); even; --even)
+        {
+            *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.CFIFO.UINT32;
+            g_usb0_function_data_pointer[pipe] += 4;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_d0_fifo
+* Description  : Writes data in D0FIFO.
+*              : Writes data by BYTE/WORD/LONG according to access size
+*              : to the pipe specified by the arguments.
+*              : Before executing this function, allocating CFIF0 in the specified pipe
+*              : should be completed.
+*              : Before executing this function, access size to the specified pipe
+*              : should be fixed and set in g_usb0_function_mbw[].
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t count     ; Data Size(Byte)
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_write_d0_fifo (uint16_t pipe, uint16_t count)
+{
+    uint16_t even;
+
+    if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
+    {
+        for (even = count; even; --even)
+        {
+            USB200.D0FIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe];
+            g_usb0_function_data_pointer[pipe] += 1;
+        }
+    }
+    else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
+    {
+        for (even = (uint16_t)(count / 2); even; --even)
+        {
+            USB200.D0FIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]);
+            g_usb0_function_data_pointer[pipe] += 2;
+        }
+    }
+    else
+    {
+        for (even = (uint16_t)(count / 4); even; --even)
+        {
+            USB200.D0FIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]);
+            g_usb0_function_data_pointer[pipe] += 4;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_d0_fifo
+* Description  : Reads data from D0FIFO.
+*              : Reads data by BYTE/WORD/LONG according to access size
+*              : to the pipe specified by the arguments.
+*              : Before executing this function, allocating DOFIF0 in the specified pipe
+*              : should be completed.
+*              : Before executing this function, access size to the specified pipe
+*              : should be fixed and set in g_usb0_function_mbw[].
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t count     ; Data Size(Byte)
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_read_d0_fifo (uint16_t pipe, uint16_t count)
+{
+    uint16_t even;
+
+    if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
+    {
+        for (even = count; even; --even)
+        {
+            *g_usb0_function_data_pointer[pipe] = USB200.D0FIFO.UINT8[HH];
+            g_usb0_function_data_pointer[pipe] += 1;
+        }
+    }
+    else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
+    {
+        for (even = (uint16_t)((count + 1) / 2); even; --even)
+        {
+            *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.D0FIFO.UINT16[H];
+            g_usb0_function_data_pointer[pipe] += 2;
+        }
+    }
+    else
+    {
+        for (even = (uint16_t)((count + 3) / 4); even; --even)
+        {
+            *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.D0FIFO.UINT32;
+            g_usb0_function_data_pointer[pipe] += 4;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_write_d1_fifo
+* Description  : Writes data in D1FIFO.
+*              : Writes data by BYTE/WORD/LONG according to access size
+*              : to the pipe specified by the arguments.
+*              : Before executing this function, allocating D1FIF0 in the specified pipe
+*              : should be completed.
+*              : Before executing this function, access size to the specified pipe
+*              : should be fixed and set in g_usb0_function_mbw[].
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t count     ; Data Size(Byte)
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_write_d1_fifo (uint16_t pipe, uint16_t count)
+{
+    uint16_t even;
+
+    if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
+    {
+        for (even = count; even; --even)
+        {
+            USB200.D1FIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe];
+            g_usb0_function_data_pointer[pipe] += 1;
+        }
+    }
+    else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
+    {
+        for (even = (uint16_t)(count / 2); even; --even)
+        {
+            USB200.D1FIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]);
+            g_usb0_function_data_pointer[pipe] += 2;
+        }
+    }
+    else
+    {
+        for (even = (uint16_t)(count / 4); even; --even)
+        {
+            USB200.D1FIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]);
+            g_usb0_function_data_pointer[pipe] += 4;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_read_d1_fifo
+* Description  : Reads data from D1FIFO.
+*              : Reads data by BYTE/WORD/LONG according to access size
+*              : to the pipe specified by the arguments.
+*              : Before executing this function, allocating D1FIF0 in the specified pipe
+*              : should be completed.
+*              : Before executing this function, access size to the specified pipe
+*              : should be fixed and set in g_usb0_function_mbw[].
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t count     ; Data Size(Byte)
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_read_d1_fifo (uint16_t pipe, uint16_t count)
+{
+    uint16_t even;
+
+    if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8)
+    {
+        for (even = count; even; --even)
+        {
+            *g_usb0_function_data_pointer[pipe] = USB200.D1FIFO.UINT8[HH];
+            g_usb0_function_data_pointer[pipe] += 1;
+        }
+    }
+    else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16)
+    {
+        for (even = (uint16_t)((count + 1) / 2); even; --even)
+        {
+            *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.D1FIFO.UINT16[H];
+            g_usb0_function_data_pointer[pipe] += 2;
+        }
+    }
+    else
+    {
+        for (even = (uint16_t)((count + 3) / 4); even; --even)
+        {
+            *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.D1FIFO.UINT32;
+            g_usb0_function_data_pointer[pipe] += 4;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_com_get_dmasize
+* Description  : Calculates access width of DMA transfer by the argument to
+*              : return as the Return Value.
+* Arguments    : uint32_t trncount   : transfer byte
+*              : uint32_t dtptr      : transfer data pointer
+* Return Value : DMA transfer size    : 0   8bit
+*              :                      : 1  16bit
+*              :                      : 2  32bit
+*******************************************************************************/
+static uint32_t usb0_function_com_get_dmasize (uint32_t trncount, uint32_t dtptr)
+{
+    uint32_t size;
+
+    if (((trncount & 0x0001) != 0) || ((dtptr & 0x00000001) != 0))
+    {
+        /*  When transfer byte count is odd         */
+        /* or transfer data area is 8-bit alignment */
+        size = 0;           /* 8bit */
+    }
+    else if (((trncount & 0x0003) != 0) || ((dtptr & 0x00000003) != 0))
+    {
+        /* When the transfer byte count is multiples of 2 */
+        /* or the transfer data area is 16-bit alignment */
+        size = 1;           /* 16bit */
+    }
+    else
+    {
+        /* When the transfer byte count is multiples of 4 */
+        /* or the transfer data area is 32-bit alignment */
+        size = 2;           /* 32bit */
+    }
+
+    return size;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_get_mbw
+* Description  : Calculates access width of DMA to return the value set in MBW.
+* Arguments    : uint32_t trncount   : transfer byte
+*              : uint32_t dtptr      : transfer data pointer
+* Return Value : FIFO transfer size   : USB_FUNCTION_BITMBW_8    8bit
+*              :                      : USB_FUNCTION_BITMBW_16  16bit
+*              :                      : USB_FUNCTION_BITMBW_32  32bit
+*******************************************************************************/
+uint16_t usb0_function_get_mbw (uint32_t trncount, uint32_t dtptr)
+{
+    uint32_t size;
+    uint16_t mbw;
+
+    size = usb0_function_com_get_dmasize(trncount, dtptr);
+
+    if (size == 0)
+    {
+        /* 8bit */
+        mbw = USB_FUNCTION_BITMBW_8;
+    }
+    else if (size == 1)
+    {
+        /* 16bit */
+        mbw = USB_FUNCTION_BITMBW_16;
+    }
+    else
+    {
+        /* 32bit */
+        mbw = USB_FUNCTION_BITMBW_32;
+    }
+
+    return mbw;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_transaction_counter
+* Description  : Sets transaction counter by the argument(PIPEnTRN).
+*              : Clears transaction before setting to enable transaction counter setting.
+* Arguments    : uint16_t pipe     ; Pipe number
+*              : uint32_t bsize    : Data transfer size
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_set_transaction_counter (uint16_t pipe, uint32_t bsize)
+{
+    uint16_t mxps;
+    uint16_t cnt;
+
+    if (bsize  == 0)
+    {
+        return;
+    }
+
+    mxps = usb0_function_get_mxps(pipe);            /* Max Packet Size */
+
+    if ((bsize % mxps) == 0)
+    {
+        cnt = (uint16_t)(bsize / mxps);
+    }
+    else
+    {
+        cnt = (uint16_t)((bsize / mxps) + 1);
+    }
+
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPE1TRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPE2TRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPE3TRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPE4TRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPE5TRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPE9TRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEATRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPEATRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPEATRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPEBTRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPECTRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPECTRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPEDTRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEETRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPEETRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPEETRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+            USB200.PIPEFTRN             = cnt;
+            RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
+                                1,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_transaction_counter
+* Description  : Clears the transaction counter by the argument.
+*              : After executing this function, the transaction counter is invalid.
+* Arguments    : uint16_t pipe     ; Pipe number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clear_transaction_counter (uint16_t pipe)
+{
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPE1TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPE2TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPE3TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPE4TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPE5TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPE9TRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEATRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPEATRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPEBTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECTRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPECTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPEDTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEETRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPEETRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
+                                0,
+                                USB_PIPEnTRE_TRENB_SHIFT,
+                                USB_PIPEnTRE_TRENB);
+            RZA_IO_RegWrite_16(&USB200.PIPEFTRE,
+                                1,
+                                USB_PIPEnTRE_TRCLR_SHIFT,
+                                USB_PIPEnTRE_TRCLR);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_stop_transfer
+* Description  : Stops the USB transfer in the pipe specified by the argument.
+*              : After stopping the USB transfer, clears the buffer allocated in
+*              : the pipe.
+*              : After executing this function, allocation in FIF0 becomes USB_FUNCTION_PIPE0;
+*              : invalid. After executing this function, BRDY/NRDY/BEMP interrupt
+*              : in the corresponding pipe becomes invalid. Sequence bit is also
+*              : cleared.
+* Arguments    : uint16_t  pipe     ; Pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_stop_transfer (uint16_t pipe)
+{
+    uint16_t usefifo;
+    uint32_t remain;
+    uint16_t fifo;
+
+    usb0_function_set_pid_nak(pipe);
+
+    usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
+    switch (usefifo)
+    {
+        case USB_FUNCTION_D0FIFO_USE:
+            usb0_function_clear_transaction_counter(pipe);
+            USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
+            fifo = USB_FUNCTION_D0USE;
+        break;
+
+        case USB_FUNCTION_D1FIFO_USE:
+            usb0_function_clear_transaction_counter(pipe);
+            USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
+            fifo = USB_FUNCTION_D1USE;
+        break;
+
+        case USB_FUNCTION_D0FIFO_DMA:
+            remain = Userdef_USB_usb0_function_stop_dma0();
+            usb0_function_dma_stop_d0(pipe, remain);
+            usb0_function_clear_transaction_counter(pipe);
+            USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
+            fifo = USB_FUNCTION_D0DMA;
+        break;
+
+        case USB_FUNCTION_D1FIFO_DMA:
+            remain = Userdef_USB_usb0_function_stop_dma1();
+            usb0_function_dma_stop_d1(pipe, remain);
+            usb0_function_clear_transaction_counter(pipe);
+            USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;        /* Buffer Clear */
+            fifo = USB_FUNCTION_D1DMA;
+        break;
+
+        default:
+            usb0_function_clear_transaction_counter(pipe);
+            USB200.CFIFOCTR =  USB_FUNCTION_BITBCLR;        /* Buffer Clear */
+            fifo = USB_FUNCTION_CUSE;
+        break;
+    }
+
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, fifo, DEVDRV_USBF_NO, USB_FUNCTION_BITMBW_16);
+
+    /* Interrupt of pipe set is disabled */
+    usb0_function_disable_brdy_int(pipe);
+    usb0_function_disable_nrdy_int(pipe);
+    usb0_function_disable_bemp_int(pipe);
+
+    usb0_function_aclrm(pipe);
+    usb0_function_set_csclr(pipe);
+
+    if ( g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT )
+    {
+        g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES;
+    }
+
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_dfacc_d0
+* Description  : Sets the DFACC setting value in D0FIFO using the transfer size.
+* Arguments    : uint16_t mbw     ; MBW
+*              : uint16_t count   ; data count
+* Return Value : DFACC Access mode
+*******************************************************************************/
+static uint16_t usb0_function_set_dfacc_d0 (uint16_t mbw, uint32_t count)
+{
+    uint16_t dfacc = 0;
+
+#ifndef __USB_FUNCTION_DF_ACC_ENABLE__
+    RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                        0,
+                        USB_DnFBCFG_DFACC_SHIFT,
+                        USB_DnFBCFG_DFACC);
+    RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                        0,
+                        USB_DnFBCFG_TENDE_SHIFT,
+                        USB_DnFBCFG_TENDE);
+    dfacc = 0;
+#else
+    if (mbw == USB_FUNCTION_BITMBW_32)
+    {
+        if ((count % 32) == 0)
+        {
+            /* 32byte transfer */
+            RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                                2,
+                                USB_DnFBCFG_DFACC_SHIFT,
+                                USB_DnFBCFG_DFACC);
+            RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                                0,
+                                USB_DnFBCFG_TENDE_SHIFT,
+                                USB_DnFBCFG_TENDE);
+            dfacc = 2;
+        }
+        else if ((count % 16) == 0)
+        {
+            /* 16byte transfer */
+            RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                                1,
+                                USB_DnFBCFG_DFACC_SHIFT,
+                                USB_DnFBCFG_DFACC);
+            RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                                0,
+                                USB_DnFBCFG_TENDE_SHIFT,
+                                USB_DnFBCFG_TENDE);
+            dfacc = 1;
+        }
+        else
+        {
+            RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                                0,
+                                USB_DnFBCFG_DFACC_SHIFT,
+                                USB_DnFBCFG_DFACC);
+            RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                                0,
+                                USB_DnFBCFG_TENDE_SHIFT,
+                                USB_DnFBCFG_TENDE);
+            dfacc = 0;
+        }
+    }
+    else if (mbw == USB_FUNCTION_BITMBW_16)
+    {
+        RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                            0,
+                            USB_DnFBCFG_DFACC_SHIFT,
+                            USB_DnFBCFG_DFACC);
+        RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                            0,
+                            USB_DnFBCFG_TENDE_SHIFT,
+                            USB_DnFBCFG_TENDE);
+        dfacc = 0;
+    }
+    else
+    {
+        RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                            0,
+                            USB_DnFBCFG_DFACC_SHIFT,
+                            USB_DnFBCFG_DFACC);
+        RZA_IO_RegWrite_16(&USB200.D0FBCFG,
+                            0,
+                            USB_DnFBCFG_TENDE_SHIFT,
+                            USB_DnFBCFG_TENDE);
+        dfacc = 0;
+    }
+#endif
+    return dfacc;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_dfacc_d1
+* Description  : Set the DFACC setting value in D1FIFO using the transfer size.
+* Arguments    : uint16_t mbw     ; MBW
+*              : uint16_t count   ; data count
+* Return Value : DFACC Access mode
+*******************************************************************************/
+static uint16_t usb0_function_set_dfacc_d1 (uint16_t mbw, uint32_t count)
+{
+    uint16_t dfacc = 0;
+
+#ifndef __USB_FUNCTION_DF_ACC_ENABLE__
+    RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                        0,
+                        USB_DnFBCFG_DFACC_SHIFT,
+                        USB_DnFBCFG_DFACC);
+    RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                        0,
+                        USB_DnFBCFG_TENDE_SHIFT,
+                        USB_DnFBCFG_TENDE);
+    dfacc = 0;
+#else
+    if (mbw == USB_FUNCTION_BITMBW_32)
+    {
+        if ((count % 32) == 0)
+        {
+            /* 32byte transfer */
+            RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                                2,
+                                USB_DnFBCFG_DFACC_SHIFT,
+                                USB_DnFBCFG_DFACC);
+            RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                                0,
+                                USB_DnFBCFG_TENDE_SHIFT,
+                                USB_DnFBCFG_TENDE);
+            dfacc = 2;
+        }
+        else if ((count % 16) == 0)
+        {
+            /* 16byte transfer */
+            RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                                1,
+                                USB_DnFBCFG_DFACC_SHIFT,
+                                USB_DnFBCFG_DFACC);
+            RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                                0,
+                                USB_DnFBCFG_TENDE_SHIFT,
+                                USB_DnFBCFG_TENDE);
+            dfacc = 1;
+        }
+        else
+        {
+            RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                                0,
+                                USB_DnFBCFG_DFACC_SHIFT,
+                                USB_DnFBCFG_DFACC);
+            RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                                0,
+                                USB_DnFBCFG_TENDE_SHIFT,
+                                USB_DnFBCFG_TENDE);
+            dfacc = 0;
+        }
+    }
+    else if (mbw == USB_FUNCTION_BITMBW_16)
+    {
+        RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                            0,
+                            USB_DnFBCFG_DFACC_SHIFT,
+                            USB_DnFBCFG_DFACC);
+        RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                            0,
+                            USB_DnFBCFG_TENDE_SHIFT,
+                            USB_DnFBCFG_TENDE);
+        dfacc = 0;
+    }
+    else
+    {
+        RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                            0,
+                            USB_DnFBCFG_DFACC_SHIFT,
+                            USB_DnFBCFG_DFACC);
+        RZA_IO_RegWrite_16(&USB200.D1FBCFG,
+                            0,
+                            USB_DnFBCFG_TENDE_SHIFT,
+                            USB_DnFBCFG_TENDE);
+        dfacc = 0;
+    }
+#endif
+
+    return dfacc;
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_dma.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,346 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_dma.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+static void usb0_function_dmaint(uint16_t fifo);
+static void usb0_function_dmaint_buf2fifo(uint16_t pipe);
+static void usb0_function_dmaint_fifo2buf(uint16_t pipe);
+
+
+/*******************************************************************************
+* Function Name: usb0_function_dma_stop_d0
+* Description  : D0FIFO DMA stop
+* Arguments    : uint16_t pipe      : pipe number
+*              : uint32_t remain    : transfer byte
+* Return Value : none
+*******************************************************************************/
+void usb0_function_dma_stop_d0 (uint16_t pipe, uint32_t remain)
+{
+    uint16_t dtln;
+    uint16_t dfacc;
+    uint16_t buffer;
+    uint16_t sds_b = 1;
+
+    dfacc = RZA_IO_RegRead_16(&USB200.D0FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC);
+
+    if (dfacc == 2)
+    {
+        sds_b = 32;
+    }
+    else if (dfacc == 1)
+    {
+        sds_b = 16;
+    }
+    else
+    {
+        if (g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 2)
+        {
+            sds_b = 4;
+        }
+        else if (g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 1)
+        {
+            sds_b = 2;
+        }
+        else
+        {
+            sds_b = 1;
+        }
+    }
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+    {
+        if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE)
+        {
+            buffer = USB200.D0FIFOCTR;
+            dtln   = (buffer & USB_FUNCTION_BITDTLN);
+
+            if ((dtln % sds_b) != 0)
+            {
+                remain += (sds_b - (dtln % sds_b));
+            }
+            g_usb0_function_PipeDataSize[pipe] = (g_usb0_function_data_count[pipe] - remain);
+            g_usb0_function_data_count[pipe]   = remain;
+        }
+    }
+
+    RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_dma_stop_d1
+* Description  : D1FIFO DMA stop
+* Arguments    : uint16_t pipe      : pipe number
+*              : uint32_t remain    : transfer byte
+* Return Value : none
+*******************************************************************************/
+void usb0_function_dma_stop_d1 (uint16_t pipe, uint32_t remain)
+{
+    uint16_t dtln;
+    uint16_t dfacc;
+    uint16_t buffer;
+    uint16_t sds_b = 1;
+
+    dfacc = RZA_IO_RegRead_16(&USB200.D1FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC);
+
+    if (dfacc == 2)
+    {
+        sds_b = 32;
+    }
+    else if (dfacc == 1)
+    {
+        sds_b = 16;
+    }
+    else
+    {
+        if (g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 2)
+        {
+            sds_b = 4;
+        }
+        else if (g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 1)
+        {
+            sds_b = 2;
+        }
+        else
+        {
+            sds_b = 1;
+        }
+    }
+
+    if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
+    {
+        if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE)
+        {
+            buffer = USB200.D1FIFOCTR;
+            dtln   = (buffer & USB_FUNCTION_BITDTLN);
+
+            if ((dtln % sds_b) != 0)
+            {
+                remain += (sds_b - (dtln % sds_b));
+            }
+            g_usb0_function_PipeDataSize[pipe] = (g_usb0_function_data_count[pipe] - remain);
+            g_usb0_function_data_count[pipe]   = remain;
+        }
+    }
+
+    RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_dma_interrupt_d0fifo
+* Description  : This function is DMA interrupt handler entry.
+*              : Execute usb0_function_dmaint() after disabling DMA interrupt in this function.
+*              : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D0FIFO_DMA is
+*              : specified by dma->fifo.
+*              : Register this function as DMA complete interrupt.
+* Arguments    : uint32_t int_sense ; Interrupts detection mode
+*              :                    ;  INTC_LEVEL_SENSITIVE : Level sense
+*              :                    ;  INTC_EDGE_TRIGGER : Edge trigger
+* Return Value : none
+*******************************************************************************/
+void usb0_function_dma_interrupt_d0fifo (uint32_t int_sense)
+{
+    usb0_function_dmaint(USB_FUNCTION_D0FIFO);
+    g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_dma_interrupt_d1fifo
+* Description  : This function is DMA interrupt handler entry.
+*              : Execute usb0_function_dmaint() after disabling DMA interrupt in this function.
+*              : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D1FIFO_DMA is
+*              : specified by dma->fifo.
+*              : Register this function as DMA complete interrupt.
+* Arguments    : uint32_t int_sense ; Interrupts detection mode
+*              :                    ;  INTC_LEVEL_SENSITIVE : Level sense
+*              :                    ;  INTC_EDGE_TRIGGER : Edge trigger
+* Return Value : none
+*******************************************************************************/
+void usb0_function_dma_interrupt_d1fifo (uint32_t int_sense)
+{
+    usb0_function_dmaint(USB_FUNCTION_D1FIFO);
+    g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_dmaint
+* Description  : This function is DMA transfer end interrupt
+* Arguments    : uint16_t fifo  ; fifo number
+*              :                ;  USB_FUNCTION_D0FIFO
+*              :                ;  USB_FUNCTION_D1FIFO
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_dmaint (uint16_t fifo)
+{
+    uint16_t pipe;
+
+    pipe = g_usb0_function_DmaPipe[fifo];
+
+    if (g_usb0_function_DmaInfo[fifo].dir == USB_FUNCTION_BUF2FIFO)
+    {
+        usb0_function_dmaint_buf2fifo(pipe);
+    }
+    else
+    {
+        usb0_function_dmaint_fifo2buf(pipe);
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_dmaint_fifo2buf
+* Description  : Executes read completion from FIFO by DMAC.
+* Arguments    : uint16_t pipe      : pipe number
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_dmaint_fifo2buf (uint16_t pipe)
+{
+    uint32_t remain;
+    uint16_t useport;
+
+    if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE)
+    {
+        useport = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
+
+        if (useport == USB_FUNCTION_D0FIFO_DMA)
+        {
+            remain = Userdef_USB_usb0_function_stop_dma0();
+            usb0_function_dma_stop_d0(pipe, remain);
+
+            if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+            {
+                if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] == USB_FUNCTION_DMA_BUSYEND)
+                {
+                    USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;
+                    g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
+                }
+                else
+                {
+                    usb0_function_enable_brdy_int(pipe);
+                }
+            }
+        }
+        else
+        {
+            remain = Userdef_USB_usb0_function_stop_dma1();
+            usb0_function_dma_stop_d1(pipe, remain);
+
+            if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+            {
+                if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] == USB_FUNCTION_DMA_BUSYEND)
+                {
+                    USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;
+                    g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
+                }
+                else
+                {
+                    usb0_function_enable_brdy_int(pipe);
+                }
+            }
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_dmaint_buf2fifo
+* Description  : Executes write completion in FIFO by DMAC.
+* Arguments    : uint16_t pipe      : pipe number
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_dmaint_buf2fifo (uint16_t pipe)
+{
+    uint32_t remain;
+    uint16_t useport;
+
+    useport = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
+
+    if (useport == USB_FUNCTION_D0FIFO_DMA)
+    {
+        remain = Userdef_USB_usb0_function_stop_dma0();
+        usb0_function_dma_stop_d0(pipe, remain);
+
+        if (g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] != 0)
+        {
+            RZA_IO_RegWrite_16(&USB200.D0FIFOCTR,
+                                1,
+                                USB_DnFIFOCTR_BVAL_SHIFT,
+                                USB_DnFIFOCTR_BVAL);
+        }
+    }
+    else
+    {
+        remain = Userdef_USB_usb0_function_stop_dma1();
+        usb0_function_dma_stop_d1(pipe, remain);
+
+        if (g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] != 0)
+        {
+            RZA_IO_RegWrite_16(&USB200.D1FIFOCTR,
+                                1,
+                                USB_DnFIFOCTR_BVAL_SHIFT,
+                                USB_DnFIFOCTR_BVAL);
+        }
+    }
+
+    usb0_function_enable_bemp_int(pipe);
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_intrn.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,249 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_intrn.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: usb0_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
+*******************************************************************************/
+#if 0
+void usb0_function_brdy_int (uint16_t status, uint16_t int_enb)
+{
+    uint32_t int_sense = 0;
+    uint16_t pipe;
+    uint16_t pipebit;
+
+    for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
+    {
+        pipebit = g_usb0_function_bit_set[pipe];
+
+        if ((status & pipebit) && (int_enb & pipebit))
+        {
+            USB200.BRDYSTS = (uint16_t)~pipebit;
+            USB200.BEMPSTS = (uint16_t)~pipebit;
+            if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA)
+            {
+                if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY)
+                {
+                    usb0_function_dma_interrupt_d0fifo(int_sense);
+                }
+
+                if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+                {
+                    usb0_function_read_dma(pipe);
+                    usb0_function_disable_brdy_int(pipe);
+                }
+                else
+                {
+                    USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;
+                    g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
+                }
+            }
+            else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA)
+            {
+                if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY)
+                {
+                    usb0_function_dma_interrupt_d1fifo(int_sense);
+                }
+
+                if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
+                {
+                    usb0_function_read_dma(pipe);
+                    usb0_function_disable_brdy_int(pipe);
+                }
+                else
+                {
+                    USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;
+                    g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
+                }
+            }
+            else
+            {
+                if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0)
+                {
+                    usb0_function_read_buffer(pipe);
+                }
+                else
+                {
+                    usb0_function_write_buffer(pipe);
+                }
+            }
+        }
+    }
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_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
+*******************************************************************************/
+void usb0_function_nrdy_int (uint16_t status, uint16_t int_enb)
+{
+    uint16_t pid;
+    uint16_t pipe;
+    uint16_t bitcheck;
+
+    bitcheck = (uint16_t)(status & int_enb);
+
+    USB200.NRDYSTS = (uint16_t)~status;
+
+    for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
+    {
+        if ((bitcheck&g_usb0_function_bit_set[pipe]) == g_usb0_function_bit_set[pipe])
+        {
+            if (RZA_IO_RegRead_16(&USB200.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1)
+            {
+                if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT)
+                {
+                    pid = usb0_function_get_pid(pipe);
+                    if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2))
+                    {
+                        g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL;
+                    }
+                    else
+                    {
+                        g_usb0_function_PipeIgnore[pipe]++;
+                        if (g_usb0_function_PipeIgnore[pipe] == 3)
+                        {
+                            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES;
+                        }
+                        else
+                        {
+                            usb0_function_set_pid_buf(pipe);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                /* USB Function */
+            }
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_bemp_int
+* Description  : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9).
+* Arguments    : uint16_t status       ; BEMPSTS Register Value
+*              : uint16_t int_enb      ; BEMPENB Register Value
+* Return Value : none
+*******************************************************************************/
+void usb0_function_bemp_int (uint16_t status, uint16_t int_enb)
+{
+    uint16_t pid;
+    uint16_t pipe;
+    uint16_t bitcheck;
+    uint16_t inbuf;
+
+    bitcheck = (uint16_t)(status & int_enb);
+
+    USB200.BEMPSTS = (uint16_t)~status;
+
+    for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
+    {
+        if ((bitcheck&g_usb0_function_bit_set[pipe]) == g_usb0_function_bit_set[pipe])
+        {
+            pid = usb0_function_get_pid(pipe);
+
+            if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2))
+            {
+                g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL;
+            }
+            else
+            {
+                inbuf = usb0_function_get_inbuf(pipe);
+
+                if (inbuf == 0)
+                {
+                    usb0_function_disable_bemp_int(pipe);
+                    usb0_function_set_pid_nak(pipe);
+                    g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
+                }
+            }
+        }
+    }
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_lib.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,2026 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_lib.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: usb0_function_enable_brdy_int
+* Description  : Enables BRDY interrupt in the pipe spceified by the argument.
+*              : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling
+*              : BRDY. Enables BRDY interrupt in the pipe specified by the argument
+*              : in the disabled status. After enabling BRDY, recover all
+*              : BEMP/NRDY/BRDY disabled/enabled status.
+* Arguments    : uint16_t pipe           ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_enable_brdy_int (uint16_t pipe)
+{
+    /* enable brdy interrupt */
+    USB200.BRDYENB |= (uint16_t)g_usb0_function_bit_set[pipe];
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_disable_brdy_int
+* Description  : Disables BRDY interrupt in the pipe spceified by the argument.
+*              : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling
+*              : BRDY. Enables BRDY interrupt in the pipe specified by the argument
+*              : in the disabled status. After disabling BRDY, recover all
+*              : BEMP/NRDY/BRDY disabled/enabled status.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_disable_brdy_int (uint16_t pipe)
+{
+    /* disable brdy interrupt */
+    USB200.BRDYENB &= (uint16_t)~(g_usb0_function_bit_set[pipe]);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_brdy_sts
+* Description  : Clear BRDY interrupt status in the pipe spceified by the argument.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clear_brdy_sts (uint16_t pipe)
+{
+    /* clear brdy status */
+    USB200.BRDYSTS = (uint16_t)~(g_usb0_function_bit_set[pipe]);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_enable_bemp_int
+* Description  : Enables BEMP interrupt in the pipe spceified by the argument.
+*              : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling
+*              : BEMP. Enables BEMP interrupt in the pipe specified by the argument
+*              : in the disabled status. After enabling BEMP, recover all
+*              : BEMP/NRDY/BRDY disabled/enabled status.
+* Arguments    : uint16_t pipe           ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_enable_bemp_int (uint16_t pipe)
+{
+    /* enable bemp interrupt */
+    USB200.BEMPENB |= (uint16_t)g_usb0_function_bit_set[pipe];
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_disable_bemp_int
+* Description  : Disables BEMP interrupt in the pipe spceified by the argument.
+*              : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling
+*              : BEMP. Enables BEMP interrupt in the pipe specified by the argument
+*              : in the disabled status. After enabling BEMP, recover all
+*              : BEMP/NRDY/BRDY disabled/enabled status.
+* Arguments    : uint16_t pipe           ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_disable_bemp_int (uint16_t pipe)
+{
+    /* disable bemp interrupt */
+    USB200.BEMPENB &= (uint16_t)~(g_usb0_function_bit_set[pipe]);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_bemp_sts
+* Description  : Clear BEMP interrupt status in the pipe spceified by the argument.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clear_bemp_sts (uint16_t pipe)
+{
+    /* clear bemp status */
+    USB200.BEMPSTS = (uint16_t)~(g_usb0_function_bit_set[pipe]);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_enable_nrdy_int
+* Description  : Enables NRDY interrupt in the pipe spceified by the argument.
+*              : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling
+*              : NRDY. Enables NRDY interrupt in the pipe specified by the argument
+*              : in the disabled status. After enabling NRDY, recover all
+*              : BEMP/NRDY/BRDY disabled/enabled status.
+* Arguments    : uint16_t pipe             ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_enable_nrdy_int (uint16_t pipe)
+{
+    /* enable nrdy interrupt */
+    USB200.NRDYENB |= (uint16_t)g_usb0_function_bit_set[pipe];
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_disable_nrdy_int
+* Description  : Disables NRDY interrupt in the pipe spceified by the argument.
+*              : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling
+*              : NRDY. Disables NRDY interrupt in the pipe specified by the argument
+*              : in the disabled status. After disabling NRDY, recover all
+*              : BEMP/NRDY/BRDY disabled/enabled status.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_disable_nrdy_int (uint16_t pipe)
+{
+    /* disable nrdy interrupt */
+    USB200.NRDYENB &= (uint16_t)~(g_usb0_function_bit_set[pipe]);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_nrdy_sts
+* Description  : Clear NRDY interrupt status in the pipe spceified by the argument.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clear_nrdy_sts (uint16_t pipe)
+{
+    /* clear nrdy status */
+    USB200.NRDYSTS = (uint16_t)~(g_usb0_function_bit_set[pipe]);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_is_hispeed
+* Description  : Returns the result of USB reset hand shake (RHST) as
+*              : return value.
+* Arguments    : none
+* Return Value : USB_FUNCTION_HIGH_SPEED    ; Hi-Speed
+*              : USB_FUNCTION_FULL_SPEED    ; Full-Speed
+*              : LOW_SPEED                  ; Low-Speed
+*              : USB_FUNCTION_NON_SPEED     ; error
+*******************************************************************************/
+uint16_t usb0_function_is_hispeed (void)
+{
+    uint16_t rhst;
+    uint16_t speed;
+
+    rhst = RZA_IO_RegRead_16(&USB200.DVSTCTR0, USB_DVSTCTR0_RHST_SHIFT, USB_DVSTCTR0_RHST);
+
+    if (rhst == USB_FUNCTION_HSMODE)
+    {
+        speed = USB_FUNCTION_HIGH_SPEED;
+    }
+    else if (rhst == USB_FUNCTION_FSMODE)
+    {
+        speed = USB_FUNCTION_FULL_SPEED;
+    }
+    else if (rhst == USB_FUNCTION_LSMODE)
+    {
+        speed = USB_FUNCTION_LOW_SPEED;
+    }
+    else
+    {
+        speed = USB_FUNCTION_NON_SPEED;
+    }
+
+    return speed;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_is_hispeed_enable
+* Description  : Returns the USB High-Speed connection enabled status as
+*              : return value.
+* Arguments    : none
+* Return Value : DEVDRV_USBF_YES  : Hi-Speed Enable
+*              : DEVDRV_USBF_NO   : Hi-Speed Disable
+*******************************************************************************/
+uint16_t usb0_function_is_hispeed_enable (void)
+{
+    uint16_t ret;
+
+    ret = DEVDRV_USBF_NO;
+
+    if (RZA_IO_RegRead_16(&USB200.SYSCFG0, USB_SYSCFG_HSE_SHIFT, USB_SYSCFG_HSE) == 1)
+    {
+        ret = DEVDRV_USBF_YES;
+    }
+
+    return ret;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_pid_buf
+* Description  : Enables communicaqtion in the pipe specified by the argument
+*              : (BUF).
+* Arguments    : uint16_t pipe             ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_pid_buf (uint16_t pipe)
+{
+    uint16_t pid;
+
+    pid = usb0_function_get_pid(pipe);
+
+    if (pid == DEVDRV_USBF_PID_STALL2)
+    {
+        usb0_function_set_pid_nak(pipe);
+    }
+
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_DCPCTR_PID_SHIFT,
+                                USB_DCPCTR_PID);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_6_8_PID_SHIFT,
+                                USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_6_8_PID_SHIFT,
+                                USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_6_8_PID_SHIFT,
+                                USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_9_PID_SHIFT,
+                                USB_PIPEnCTR_9_PID);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                DEVDRV_USBF_PID_BUF,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_pid_nak
+* Description  : Disables communication (NAK) in the pipe specified by the argument.
+*              : When the pipe status was enabling communication (BUF) before
+*              : executing before executing this function, waits in the software
+*              : until the pipe becomes ready after setting disabled.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_pid_nak (uint16_t pipe)
+{
+    uint16_t pid;
+    uint16_t pbusy;
+    uint32_t loop;
+
+    pid = usb0_function_get_pid(pipe);
+
+    if (pid == DEVDRV_USBF_PID_STALL2)
+    {
+        usb0_function_set_pid_stall(pipe);
+    }
+
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_DCPCTR_PID_SHIFT,
+                                USB_DCPCTR_PID);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_1_5_PID_SHIFT,
+                                USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_6_8_PID_SHIFT,
+                                USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_6_8_PID_SHIFT,
+                                USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_6_8_PID_SHIFT,
+                                USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_9_PID_SHIFT,
+                                USB_PIPEnCTR_9_PID);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                DEVDRV_USBF_PID_NAK,
+                                USB_PIPEnCTR_A_F_PID_SHIFT,
+                                USB_PIPEnCTR_A_F_PID);
+        break;
+
+        default:
+        break;
+    }
+
+    if (pid == DEVDRV_USBF_PID_BUF)
+    {
+        for (loop = 0; loop < 200; loop++)
+        {
+            switch (pipe)
+            {
+                case USB_FUNCTION_PIPE0:
+                    pbusy = RZA_IO_RegRead_16(&USB200.DCPCTR,
+                                                USB_DCPCTR_PBUSY_SHIFT,
+                                                USB_DCPCTR_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE1:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE1CTR,
+                                                USB_PIPEnCTR_1_5_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_1_5_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE2:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE2CTR,
+                                                USB_PIPEnCTR_1_5_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_1_5_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE3:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE3CTR,
+                                                USB_PIPEnCTR_1_5_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_1_5_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE4:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE4CTR,
+                                                USB_PIPEnCTR_1_5_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_1_5_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE5:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE5CTR,
+                                                USB_PIPEnCTR_1_5_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_1_5_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE6:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE6CTR,
+                                                USB_PIPEnCTR_6_8_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_6_8_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE7:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE7CTR,
+                                                USB_PIPEnCTR_6_8_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_6_8_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE8:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE8CTR,
+                                                USB_PIPEnCTR_6_8_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_6_8_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPE9:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPE9CTR,
+                                                USB_PIPEnCTR_9_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_9_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPEA:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPEACTR,
+                                                USB_PIPEnCTR_A_F_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_A_F_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPEB:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPEBCTR,
+                                                USB_PIPEnCTR_A_F_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_A_F_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPEC:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPECCTR,
+                                                USB_PIPEnCTR_A_F_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_A_F_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPED:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPEDCTR,
+                                                USB_PIPEnCTR_A_F_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_A_F_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPEE:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPEECTR,
+                                                USB_PIPEnCTR_A_F_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_A_F_PBUSY);
+                break;
+
+                case USB_FUNCTION_PIPEF:
+                    pbusy = RZA_IO_RegRead_16(&USB200.PIPEFCTR,
+                                                USB_PIPEnCTR_A_F_PBUSY_SHIFT,
+                                                USB_PIPEnCTR_A_F_PBUSY);
+                break;
+
+                default:
+                    pbusy   = 1;
+                break;
+            }
+
+            if (pbusy == 0)
+            {
+                break;
+            }
+            Userdef_USB_usb0_function_delay_500ns();
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_pid_stall
+* Description  : Disables communication (STALL) in the pipe specified by the
+*              : argument.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_pid_stall (uint16_t pipe)
+{
+    uint16_t pid;
+
+    pid = usb0_function_get_pid(pipe);
+    if (pid == DEVDRV_USBF_PID_BUF)
+    {
+        switch (pipe)
+        {
+            case USB_FUNCTION_PIPE0:
+                RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_DCPCTR_PID_SHIFT,
+                                    USB_DCPCTR_PID);
+            break;
+
+            case USB_FUNCTION_PIPE1:
+                RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE2:
+                RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE3:
+                RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE4:
+                RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE5:
+                RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE6:
+                RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+            break;
+
+            case USB_FUNCTION_PIPE7:
+                RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+            break;
+
+            case USB_FUNCTION_PIPE8:
+                RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+            break;
+
+            case USB_FUNCTION_PIPE9:
+                RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_9_PID_SHIFT,
+                                    USB_PIPEnCTR_9_PID);
+            break;
+
+            case USB_FUNCTION_PIPEA:
+                RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEB:
+                RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEC:
+                RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPED:
+                RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEE:
+                RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEF:
+                RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                    DEVDRV_USBF_PID_STALL2,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            default:
+            break;
+        }
+    }
+    else
+    {
+        switch (pipe)
+        {
+            case USB_FUNCTION_PIPE0:
+                RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_DCPCTR_PID_SHIFT,
+                                    USB_DCPCTR_PID);
+            break;
+
+            case USB_FUNCTION_PIPE1:
+                RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE2:
+                RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE3:
+                RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE4:
+                RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE5:
+                RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+            break;
+
+            case USB_FUNCTION_PIPE6:
+                RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+            break;
+
+            case USB_FUNCTION_PIPE7:
+                RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+            break;
+
+            case USB_FUNCTION_PIPE8:
+                RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+            break;
+
+            case USB_FUNCTION_PIPE9:
+                RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_9_PID_SHIFT,
+                                    USB_PIPEnCTR_9_PID);
+            break;
+
+            case USB_FUNCTION_PIPEA:
+                RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEB:
+                RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEC:
+                RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPED:
+                RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEE:
+                RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            case USB_FUNCTION_PIPEF:
+                RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                    DEVDRV_USBF_PID_STALL,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+            break;
+
+            default:
+            break;
+        }
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_pid_stall
+* Description  : Disables communication (NAK) in the pipe specified by the argument.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clear_pid_stall (uint16_t pipe)
+{
+    usb0_function_set_pid_nak(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_get_pid
+* Description  : Returns the pipe state specified by the argument.
+* Arguments    : uint16_t pipe          ; Pipe Number
+* Return Value : PID
+*******************************************************************************/
+uint16_t usb0_function_get_pid (uint16_t pipe)
+{
+    uint16_t pid;
+
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            pid = RZA_IO_RegRead_16(&USB200.DCPCTR,
+                                    USB_DCPCTR_PID_SHIFT,
+                                    USB_DCPCTR_PID);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE1CTR,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE2CTR,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE3CTR,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE4CTR,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE5CTR,
+                                    USB_PIPEnCTR_1_5_PID_SHIFT,
+                                    USB_PIPEnCTR_1_5_PID);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE6CTR,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE7CTR,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE8CTR,
+                                    USB_PIPEnCTR_6_8_PID_SHIFT,
+                                    USB_PIPEnCTR_6_8_PID);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            pid = RZA_IO_RegRead_16(&USB200.PIPE9CTR,
+                                    USB_PIPEnCTR_9_PID_SHIFT,
+                                    USB_PIPEnCTR_9_PID);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            pid = RZA_IO_RegRead_16(&USB200.PIPEACTR,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            pid = RZA_IO_RegRead_16(&USB200.PIPEBCTR,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            pid = RZA_IO_RegRead_16(&USB200.PIPECCTR,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            pid = RZA_IO_RegRead_16(&USB200.PIPEDCTR,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            pid = RZA_IO_RegRead_16(&USB200.PIPEECTR,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            pid = RZA_IO_RegRead_16(&USB200.PIPEFCTR,
+                                    USB_PIPEnCTR_A_F_PID_SHIFT,
+                                    USB_PIPEnCTR_A_F_PID);
+        break;
+
+        default:
+            pid = 0;
+        break;
+    }
+
+    return pid;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_csclr
+* Description  : CSPLIT status clear setting of sprit transaction in specified
+*              : pipe is performed.
+*              : When SQSET bit or SQCLR bit, and SQSET bit or SQCLR bit
+*              : in DCPCTR register are continuously changed (when the sequence
+*              : toggle bit of data PID is continuously changed over two or more pipes),
+*              : the access cycle with 120 ns and more than 5 cycle bus clock is necessary.
+*              : Do not set both SQCLR bit and SQSET bit to 1 at the same time.
+*              : In addition, both bits should be operated after PID is set to NAK.
+*              : However, when it is set to the isochronous transfer as the transfer type
+*              : (TYPE=11), writing in SQSET bit is disabled.
+* Arguments    : uint16_t pipe     ; Pipe number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_csclr (uint16_t pipe)
+{
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                1,
+                                USB_DCPCTR_CSCLR_SHIFT,
+                                USB_DCPCTR_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_CSCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_CSCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_CSCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_CSCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_CSCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_CSCLR_SHIFT,
+                                USB_PIPEnCTR_6_8_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_CSCLR_SHIFT,
+                                USB_PIPEnCTR_6_8_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_CSCLR_SHIFT,
+                                USB_PIPEnCTR_6_8_CSCLR);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                1,
+                                USB_PIPEnCTR_9_CSCLR_SHIFT,
+                                USB_PIPEnCTR_9_CSCLR);
+        break;
+
+        default:
+            /* PIPEA-F have not CSCLR */
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_sqclr
+* Description  : Sets the sequence bit of the pipe specified by the argument to
+*              : DATA0.
+* Arguments    : uint16_t pipe              ; Pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_sqclr (uint16_t pipe)
+{
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                1,
+                                USB_DCPCTR_SQCLR_SHIFT,
+                                USB_DCPCTR_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQCLR_SHIFT,
+                                USB_PIPEnCTR_1_5_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_SQCLR_SHIFT,
+                                USB_PIPEnCTR_6_8_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_SQCLR_SHIFT,
+                                USB_PIPEnCTR_6_8_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_SQCLR_SHIFT,
+                                USB_PIPEnCTR_6_8_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                1,
+                                USB_PIPEnCTR_9_SQCLR_SHIFT,
+                                USB_PIPEnCTR_9_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQCLR_SHIFT,
+                                USB_PIPEnCTR_A_F_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQCLR_SHIFT,
+                                USB_PIPEnCTR_A_F_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQCLR_SHIFT,
+                                USB_PIPEnCTR_A_F_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQCLR_SHIFT,
+                                USB_PIPEnCTR_A_F_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQCLR_SHIFT,
+                                USB_PIPEnCTR_A_F_SQCLR);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQCLR_SHIFT,
+                                USB_PIPEnCTR_A_F_SQCLR);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_sqset
+* Description  : Sets the sequence bit of the pipe specified by the argument to
+*              : DATA1.
+* Arguments    : uint16_t pipe   ; Pipe number
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_sqset (uint16_t pipe)
+{
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            RZA_IO_RegWrite_16(&USB200.DCPCTR,
+                                1,
+                                USB_DCPCTR_SQSET_SHIFT,
+                                USB_DCPCTR_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQSET_SHIFT,
+                                USB_PIPEnCTR_1_5_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQSET_SHIFT,
+                                USB_PIPEnCTR_1_5_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQSET_SHIFT,
+                                USB_PIPEnCTR_1_5_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQSET_SHIFT,
+                                USB_PIPEnCTR_1_5_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_SQSET_SHIFT,
+                                USB_PIPEnCTR_1_5_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_SQSET_SHIFT,
+                                USB_PIPEnCTR_6_8_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_SQSET_SHIFT,
+                                USB_PIPEnCTR_6_8_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_SQSET_SHIFT,
+                                USB_PIPEnCTR_6_8_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                1,
+                                USB_PIPEnCTR_9_SQSET_SHIFT,
+                                USB_PIPEnCTR_9_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQSET_SHIFT,
+                                USB_PIPEnCTR_A_F_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQSET_SHIFT,
+                                USB_PIPEnCTR_A_F_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQSET_SHIFT,
+                                USB_PIPEnCTR_A_F_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQSET_SHIFT,
+                                USB_PIPEnCTR_A_F_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQSET_SHIFT,
+                                USB_PIPEnCTR_A_F_SQSET);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_SQSET_SHIFT,
+                                USB_PIPEnCTR_A_F_SQSET);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_get_sqmon
+* Description  : Toggle bit of specified pipe is obtained
+* Arguments    : uint16_t pipe   ; Pipe number
+* Return Value : sqmon
+*******************************************************************************/
+uint16_t usb0_function_get_sqmon (uint16_t pipe)
+{
+    uint16_t sqmon;
+
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            sqmon = RZA_IO_RegRead_16(&USB200.DCPCTR,
+                                        USB_DCPCTR_SQMON_SHIFT,
+                                        USB_DCPCTR_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE1CTR,
+                                        USB_PIPEnCTR_1_5_SQMON_SHIFT,
+                                        USB_PIPEnCTR_1_5_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE2CTR,
+                                        USB_PIPEnCTR_1_5_SQMON_SHIFT,
+                                        USB_PIPEnCTR_1_5_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE3CTR,
+                                        USB_PIPEnCTR_1_5_SQMON_SHIFT,
+                                        USB_PIPEnCTR_1_5_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE4CTR,
+                                        USB_PIPEnCTR_1_5_SQMON_SHIFT,
+                                        USB_PIPEnCTR_1_5_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE5CTR,
+                                        USB_PIPEnCTR_1_5_SQMON_SHIFT,
+                                        USB_PIPEnCTR_1_5_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE6CTR,
+                                        USB_PIPEnCTR_6_8_SQMON_SHIFT,
+                                        USB_PIPEnCTR_6_8_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE7CTR,
+                                        USB_PIPEnCTR_6_8_SQMON_SHIFT,
+                                        USB_PIPEnCTR_6_8_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE8CTR,
+                                        USB_PIPEnCTR_6_8_SQMON_SHIFT,
+                                        USB_PIPEnCTR_6_8_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPE9CTR,
+                                        USB_PIPEnCTR_9_SQMON_SHIFT,
+                                        USB_PIPEnCTR_9_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPEACTR,
+                                        USB_PIPEnCTR_A_F_SQMON_SHIFT,
+                                        USB_PIPEnCTR_A_F_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPEBCTR,
+                                        USB_PIPEnCTR_A_F_SQMON_SHIFT,
+                                        USB_PIPEnCTR_A_F_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPECCTR,
+                                        USB_PIPEnCTR_A_F_SQMON_SHIFT,
+                                        USB_PIPEnCTR_A_F_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPEDCTR,
+                                        USB_PIPEnCTR_A_F_SQMON_SHIFT,
+                                        USB_PIPEnCTR_A_F_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPEECTR,
+                                        USB_PIPEnCTR_A_F_SQMON_SHIFT,
+                                        USB_PIPEnCTR_A_F_SQMON);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            sqmon = RZA_IO_RegRead_16(&USB200.PIPEFCTR,
+                                        USB_PIPEnCTR_A_F_SQMON_SHIFT,
+                                        USB_PIPEnCTR_A_F_SQMON);
+        break;
+
+        default:
+            sqmon = 0;
+        break;
+    }
+
+    return sqmon;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_aclrm
+* Description  : The buffer of specified pipe is initialized
+* Arguments    : uint16_t pipe    : Pipe
+* Return Value : none
+*******************************************************************************/
+void usb0_function_aclrm (uint16_t pipe)
+{
+    usb0_function_set_aclrm(pipe);
+    usb0_function_clr_aclrm(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_set_aclrm
+* Description  : The auto buffer clear mode of specified pipe is enabled
+* Arguments    : uint16_t pipe    : Pipe
+* Return Value : none
+*******************************************************************************/
+void usb0_function_set_aclrm (uint16_t pipe)
+{
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                1,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_ACLRM_SHIFT,
+                                USB_PIPEnCTR_6_8_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_ACLRM_SHIFT,
+                                USB_PIPEnCTR_6_8_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                1,
+                                USB_PIPEnCTR_6_8_ACLRM_SHIFT,
+                                USB_PIPEnCTR_6_8_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                1,
+                                USB_PIPEnCTR_9_ACLRM_SHIFT,
+                                USB_PIPEnCTR_9_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                1,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                1,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                1,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clr_aclrm
+* Description  : The auto buffer clear mode of specified pipe is enabled
+* Arguments    : uint16_t pipe    : Pipe
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clr_aclrm (uint16_t pipe)
+{
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            RZA_IO_RegWrite_16(&USB200.PIPE1CTR,
+                                0,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            RZA_IO_RegWrite_16(&USB200.PIPE2CTR,
+                                0,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            RZA_IO_RegWrite_16(&USB200.PIPE3CTR,
+                                0,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            RZA_IO_RegWrite_16(&USB200.PIPE4CTR,
+                                0,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            RZA_IO_RegWrite_16(&USB200.PIPE5CTR,
+                                0,
+                                USB_PIPEnCTR_1_5_ACLRM_SHIFT,
+                                USB_PIPEnCTR_1_5_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            RZA_IO_RegWrite_16(&USB200.PIPE6CTR,
+                                0,
+                                USB_PIPEnCTR_6_8_ACLRM_SHIFT,
+                                USB_PIPEnCTR_6_8_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            RZA_IO_RegWrite_16(&USB200.PIPE7CTR,
+                                0,
+                                USB_PIPEnCTR_6_8_ACLRM_SHIFT,
+                                USB_PIPEnCTR_6_8_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            RZA_IO_RegWrite_16(&USB200.PIPE8CTR,
+                                0,
+                                USB_PIPEnCTR_6_8_ACLRM_SHIFT,
+                                USB_PIPEnCTR_6_8_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            RZA_IO_RegWrite_16(&USB200.PIPE9CTR,
+                                0,
+                                USB_PIPEnCTR_9_ACLRM_SHIFT,
+                                USB_PIPEnCTR_9_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            RZA_IO_RegWrite_16(&USB200.PIPEACTR,
+                                0,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            RZA_IO_RegWrite_16(&USB200.PIPEBCTR,
+                                0,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            RZA_IO_RegWrite_16(&USB200.PIPECCTR,
+                                0,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            RZA_IO_RegWrite_16(&USB200.PIPEDCTR,
+                                0,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            RZA_IO_RegWrite_16(&USB200.PIPEECTR,
+                                0,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            RZA_IO_RegWrite_16(&USB200.PIPEFCTR,
+                                0,
+                                USB_PIPEnCTR_A_F_ACLRM_SHIFT,
+                                USB_PIPEnCTR_A_F_ACLRM);
+        break;
+
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_get_inbuf
+* Description  : Returns INBUFM of the pipe specified by the argument.
+* Arguments    : uint16_t pipe             ; Pipe Number
+* Return Value : inbuf
+*******************************************************************************/
+uint16_t usb0_function_get_inbuf (uint16_t pipe)
+{
+    uint16_t inbuf;
+
+    switch (pipe)
+    {
+        case USB_FUNCTION_PIPE0:
+            inbuf = 0;
+        break;
+
+        case USB_FUNCTION_PIPE1:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPE1CTR,
+                                    USB_PIPEnCTR_1_5_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_1_5_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPE2:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPE2CTR,
+                                    USB_PIPEnCTR_1_5_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_1_5_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPE3:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPE3CTR,
+                                    USB_PIPEnCTR_1_5_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_1_5_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPE4:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPE4CTR,
+                                    USB_PIPEnCTR_1_5_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_1_5_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPE5:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPE5CTR,
+                                    USB_PIPEnCTR_1_5_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_1_5_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPE6:
+            inbuf = 0;
+        break;
+
+        case USB_FUNCTION_PIPE7:
+            inbuf = 0;
+        break;
+
+        case USB_FUNCTION_PIPE8:
+            inbuf = 0;
+        break;
+
+        case USB_FUNCTION_PIPE9:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPE9CTR,
+                                    USB_PIPEnCTR_9_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_9_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPEA:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPEACTR,
+                                    USB_PIPEnCTR_A_F_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_A_F_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPEB:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPEBCTR,
+                                    USB_PIPEnCTR_A_F_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_A_F_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPEC:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPECCTR,
+                                    USB_PIPEnCTR_A_F_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_A_F_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPED:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPEDCTR,
+                                    USB_PIPEnCTR_A_F_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_A_F_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPEE:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPEECTR,
+                                    USB_PIPEnCTR_A_F_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_A_F_INBUFM);
+        break;
+
+        case USB_FUNCTION_PIPEF:
+            inbuf = RZA_IO_RegRead_16(&USB200.PIPEFCTR,
+                                    USB_PIPEnCTR_A_F_INBUFM_SHIFT,
+                                    USB_PIPEnCTR_A_F_INBUFM);
+        break;
+
+        default:
+            inbuf = 0;
+        break;
+    }
+
+    return inbuf;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_setting_interrupt
+* Description  : Sets the USB module interrupt level.
+* Arguments    : uint8_t level ;interrupt level
+* Return Value : none
+*******************************************************************************/
+#if 0
+void usb0_function_setting_interrupt (uint8_t level)
+{
+    uint16_t d0fifo_dmaintid;
+    uint16_t d1fifo_dmaintid;
+
+    R_INTC_RegistIntFunc(INTC_ID_USBI0, usb0_function_interrupt);
+    R_INTC_SetPriority(INTC_ID_USBI0, level);
+    R_INTC_Enable(INTC_ID_USBI0);
+
+    d0fifo_dmaintid = Userdef_USB_usb0_function_d0fifo_dmaintid();
+
+    if (d0fifo_dmaintid != 0xFFFF)
+    {
+        R_INTC_RegistIntFunc(d0fifo_dmaintid, usb0_function_dma_interrupt_d0fifo);
+        R_INTC_SetPriority(d0fifo_dmaintid, level);
+        R_INTC_Enable(d0fifo_dmaintid);
+    }
+
+    d1fifo_dmaintid = Userdef_USB_usb0_function_d1fifo_dmaintid();
+
+    if (d1fifo_dmaintid != 0xFFFF)
+    {
+        R_INTC_RegistIntFunc(d1fifo_dmaintid, usb0_function_dma_interrupt_d1fifo);
+        R_INTC_SetPriority(d1fifo_dmaintid, level);
+        R_INTC_Enable(d1fifo_dmaintid);
+    }
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_reset_module
+* Description  : Initializes the USB module.
+*              : Enables providing clock to the USB module.
+*              : Sets USB bus wait register.
+* Arguments    : uint16_t clockmode ; 48MHz ; USBFCLOCK_X1_48MHZ
+*              :                    ; 12MHz ; USBFCLOCK_EXTAL_12MHZ
+* Return Value : none
+*******************************************************************************/
+void usb0_function_reset_module (uint16_t clockmode)
+{
+    /* UPLLE bit is only USB0 */
+    if (RZA_IO_RegRead_16(&USB200.SYSCFG0,
+                                USB_SYSCFG_UPLLE_SHIFT,
+                                USB_SYSCFG_UPLLE) == 1)
+    {
+        if ((USB200.SYSCFG0 & USB_FUNCTION_BITUCKSEL) != clockmode)
+        {
+            RZA_IO_RegWrite_16(&USB200.SUSPMODE,
+                                0,
+                                USB_SUSPMODE_SUSPM_SHIFT,
+                                USB_SUSPMODE_SUSPM);
+            USB200.SYSCFG0 = 0;
+            USB200.SYSCFG0 = (USB_FUNCTION_BITUPLLE | clockmode);
+            Userdef_USB_usb0_function_delay_xms(1);
+            RZA_IO_RegWrite_16(&USB200.SUSPMODE,
+                                1,
+                                USB_SUSPMODE_SUSPM_SHIFT,
+                                USB_SUSPMODE_SUSPM);
+        }
+        else
+        {
+            RZA_IO_RegWrite_16(&USB200.SUSPMODE,
+                                0,
+                                USB_SUSPMODE_SUSPM_SHIFT,
+                                USB_SUSPMODE_SUSPM);
+            Userdef_USB_usb0_function_delay_xms(1);
+            RZA_IO_RegWrite_16(&USB200.SUSPMODE,
+                                1,
+                                USB_SUSPMODE_SUSPM_SHIFT,
+                                USB_SUSPMODE_SUSPM);
+        }
+    }
+    else
+    {
+        RZA_IO_RegWrite_16(&USB200.SUSPMODE,
+                            0,
+                            USB_SUSPMODE_SUSPM_SHIFT,
+                            USB_SUSPMODE_SUSPM);
+        USB200.SYSCFG0 = 0;
+        USB200.SYSCFG0 = (USB_FUNCTION_BITUPLLE | clockmode);
+        Userdef_USB_usb0_function_delay_xms(1);
+        RZA_IO_RegWrite_16(&USB200.SUSPMODE,
+                            1,
+                            USB_SUSPMODE_SUSPM_SHIFT,
+                            USB_SUSPMODE_SUSPM);
+    }
+
+    USB200.BUSWAIT = (uint16_t)(USB_FUNCTION_BUSWAIT_05 & USB_FUNCTION_BITBWAIT);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_get_buf_size
+* Description  : Obtains pipe buffer size specified by the argument and
+*              : maximum packet size of the USB device in use.
+*              : When USB_FUNCTION_PIPE0 is specified by the argument, obtains the maximum
+*              : packet size of the USB device using the corresponding pipe.
+*              : For the case that USB_FUNCTION_PIPE0 is not assigned by the argument, when the
+*              : corresponding pipe is in continuous transfer mode,
+*              : obtains the buffer size allocated in the corresponcing pipe,
+*              : when incontinuous transfer, obtains maximum packet size.
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : Maximum packet size or buffer size
+*******************************************************************************/
+uint16_t usb0_function_get_buf_size (uint16_t pipe)
+{
+    uint16_t size;
+    uint16_t bufsize;
+
+    if (pipe == USB_FUNCTION_PIPE0)
+    {
+        size = RZA_IO_RegRead_16(&USB200.DCPMAXP,
+                                USB_DCPMAXP_MXPS_SHIFT,
+                                USB_DCPMAXP_MXPS);
+    }
+    else
+    {
+        if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_CNTMD_SHIFT, USB_PIPECFG_CNTMD) == 1)
+        {
+            bufsize = RZA_IO_RegRead_16(&g_usb0_function_pipebuf[pipe], USB_PIPEBUF_BUFSIZE_SHIFT, USB_PIPEBUF_BUFSIZE);
+            size = (uint16_t)((bufsize + 1) * USB_FUNCTION_PIPExBUF);
+        }
+        else
+        {
+            size = RZA_IO_RegRead_16(&g_usb0_function_pipemaxp[pipe], USB_PIPEMAXP_MXPS_SHIFT, USB_PIPEMAXP_MXPS);
+        }
+    }
+    return size;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_get_mxps
+* Description  : Obtains maximum packet size of the USB device using the pipe
+*              : specified by the argument.
+* Arguments    : uint16_t pipe      ; Pipe Number
+* Return Value : Max Packet Size
+*******************************************************************************/
+uint16_t usb0_function_get_mxps (uint16_t pipe)
+{
+    uint16_t size;
+
+    if (pipe == USB_FUNCTION_PIPE0)
+    {
+        size = RZA_IO_RegRead_16(&USB200.DCPMAXP,
+                                USB_DCPMAXP_MXPS_SHIFT,
+                                USB_DCPMAXP_MXPS);
+    }
+    else
+    {
+        size = RZA_IO_RegRead_16(&g_usb0_function_pipemaxp[pipe], USB_PIPEMAXP_MXPS_SHIFT, USB_PIPEMAXP_MXPS);
+    }
+    return size;
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_api.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,441 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_api.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+#include "dev_drv.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: usb0_api_function_init
+* Description  : Initializes the USB module in the USB function mode.
+* Arguments    : uint8_t  int_level ; interruput level
+*              : uint16_t mode      : Speed modes
+*              :                    :  USB_FUCNTION_HIGH_SPEED: High-speed device
+*              :                    :  USB_FUCNTION_FULL_SPEED: Full-speed device
+*              : uint16_t clockmode ; 48MHz ; USBFCLOCK_X1_48MHZ
+*              :                    ; 12MHz ; USBFCLOCK_EXTAL_12MHZ
+* Return Value : none
+*******************************************************************************/
+#if 0
+void usb0_api_function_init (uint8_t int_level, uint16_t mode, uint16_t clockmode)
+{
+    volatile uint8_t dummy_buf;
+
+    CPG.STBCR7  &= 0xfd;                        /* The clock of USB0 modules is permitted */
+    dummy_buf   = CPG.STBCR7;                   /* (Dummy read) */
+
+    usb0_function_setting_interrupt(int_level);
+
+    usb0_function_reset_module(clockmode);      /* reset USB module with setting tranciever */
+                                                /* and HSE=1                                */
+
+    usb0_function_init_status();                /* clear variables                          */
+
+    usb0_function_InitModule(mode);             /* select USB Function and Interrupt Enable */
+                                                /* Detect USB Device to attach or detach    */
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_api_function_IsConfigured
+* Description  : Checks if the USB device is configured to return the result as
+*              : the return value.
+* Arguments    : none
+* Return Value : DEVDRV_USBF_YES  : Configured & Configured Suspend
+*              : DEVDRV_USBF_NO   : not Configured
+*******************************************************************************/
+uint16_t usb0_api_function_IsConfigured (void)
+{
+    uint16_t dvst;
+
+    dvst = usb0_function_GetDeviceState();
+
+    if ((dvst == USB_FUNCTION_DVST_CONFIGURED) ||
+        (dvst == USB_FUNCTION_DVST_CONFIGURED_SUSPEND))
+    {
+        return DEVDRV_USBF_YES;
+    }
+
+    return DEVDRV_USBF_NO;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_GetDeviceState
+* Description  : Returns the state of USB device.
+* Arguments    : none
+* Return Value : Device States
+*******************************************************************************/
+uint16_t usb0_function_GetDeviceState (void)
+{
+    uint16_t dvsq;
+    uint16_t dvst;
+
+    dvsq = USB200.INTSTS0;
+    switch(dvsq & USB_FUNCTION_BITDVSQ)
+    {
+        case USB_FUNCTION_DS_POWR:                      /* Power state *//* power-on */
+            dvst = USB_FUNCTION_DVST_POWERED;
+        break;
+
+        case USB_FUNCTION_DS_DFLT:                      /* Default state *//* bus-reset */
+            dvst = USB_FUNCTION_DVST_DEFAULT;
+        break;
+
+        case USB_FUNCTION_DS_ADDS:                      /* Address state */
+            dvst = USB_FUNCTION_DVST_ADDRESS;
+        break;
+
+        case USB_FUNCTION_DS_CNFG:                      /* Configured state */
+            dvst = USB_FUNCTION_DVST_CONFIGURED;
+        break;
+
+        case USB_FUNCTION_DS_SPD_CNFG:                  /* Configured Suspend state */
+            dvst = USB_FUNCTION_DVST_CONFIGURED_SUSPEND;
+        break;
+
+        case USB_FUNCTION_DS_SPD_POWR:                  /* Power      Suspend state */
+        case USB_FUNCTION_DS_SPD_DFLT:                  /* Default    Suspend state */
+        case USB_FUNCTION_DS_SPD_ADDR:                  /* Address    Suspend state */
+            dvst = USB_FUNCTION_DVST_SUSPEND;
+        break;
+
+        default:                                        /* error */
+            dvst = USB_FUNCTION_DVST_SUSPEND;
+        break;
+    }
+
+    return dvst;
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_start_receive_transfer
+* Description  : Starts USB data reception using the pipe specified in the argument.
+*              : The FIFO for using is set in the pipe definition table.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint32_t size      ; Data Size
+*              : uint8_t *data      ; Data data Address
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    usb0_function_start_receive_transfer(pipe, size, data);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_start_send_transfer
+* Description  : Starts the USB data communication using pipe specified by the argument.
+* Arguments    : uint16_t pipe     ; Pipe Number
+*              : uint32_t size     ; Data Size
+*              : uint8_t *data     ; Data data Address
+* Return Value : DEVDRV_USBF_WRITEEND           ; Write end
+*              : DEVDRV_USBF_WRITESHRT          ; short data
+*              : DEVDRV_USBF_WRITING            ; Continue of data write
+*              : DEVDRV_USBF_WRITEDMA           ; Write DMA
+*              : DEVDRV_USBF_FIFOERROR          ; FIFO status
+*******************************************************************************/
+uint16_t usb0_api_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data)
+{
+    uint16_t status;
+
+    status = usb0_function_start_send_transfer(pipe, size, data);
+
+    return status;
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_check_pipe_status
+* Description  : Starts USB data reception using the pipe specified in the argument.
+*              : The FIFO for using is set in the pipe definition table.
+* Arguments    : uint16_t  pipe     ; Pipe Number
+*              : uint32_t *size     ; Data Size
+* Return Value : Pipe Status
+*******************************************************************************/
+uint16_t usb0_api_function_check_pipe_status (uint16_t pipe, uint32_t * size)
+{
+    if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_DONE)
+    {
+        *size = g_usb0_function_PipeDataSize[pipe];
+        g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
+
+        return DEVDRV_USBF_PIPE_DONE;
+    }
+    else if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_NORES)
+    {
+        *size = 0;
+        g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
+
+        return DEVDRV_USBF_PIPE_NORES;
+    }
+    else if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_STALL)
+    {
+        *size = 0;
+        g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
+
+        return DEVDRV_USBF_PIPE_STALL;
+    }
+    else if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_FIFOERROR)
+    {
+        *size = 0;
+        g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
+
+        return DEVDRV_USBF_FIFOERROR;
+    }
+    else
+    {
+        /* Do Nothing */
+    }
+
+    return g_usb0_function_pipe_status[pipe];
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_clear_pipe_status
+* Description  : Starts USB data reception using the pipe specified in the argument.
+*              : The FIFO for using is set in the pipe definition table.
+* Arguments    : uint16_t  pipe     ; Pipe Number
+* Return Value : Pipe Status
+*******************************************************************************/
+void usb0_api_function_clear_pipe_status (uint16_t pipe)
+{
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_IDLE;
+    g_usb0_function_PipeDataSize[pipe] = 0;
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_pid_buf
+* Description  : Enables communicaqtion in the pipe specified by the argument
+*              : (BUF).
+* Arguments    : uint16_t pipe             ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_pid_buf (uint16_t pipe)
+{
+    usb0_function_set_pid_buf(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_pid_nak
+* Description  : Disables communication (NAK) in the pipe specified by the argument.
+*              : When the pipe status was enabling communication (BUF) before
+*              : executing before executing this function, waits in the software
+*              : until the pipe becomes ready after setting disabled.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_pid_nak (uint16_t pipe)
+{
+    usb0_function_set_pid_nak(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_pid_stall
+* Description  : Disables communication (STALL) in the pipe specified by the
+*              : argument.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_pid_stall (uint16_t pipe)
+{
+    usb0_function_set_pid_stall(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_clear_pid_stall
+* Description  : Disables communication (NAK) in the pipe specified by the argument.
+* Arguments    : uint16_t pipe            ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_clear_pid_stall (uint16_t pipe)
+{
+    usb0_function_clear_pid_stall(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_get_pid
+* Description  : Returns the pipe state specified by the argument.
+* Arguments    : uint16_t pipe          ; Pipe Number
+* Return Value : PID
+*******************************************************************************/
+uint16_t usb0_api_function_get_pid (uint16_t pipe)
+{
+    uint16_t pid;
+
+    pid = usb0_function_get_pid(pipe);
+
+    return pid;
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_check_stall
+* Description  :
+* Arguments    : uint16_t pipe          ; Pipe Number
+* Return Value : PID
+*******************************************************************************/
+int32_t usb0_api_function_check_stall (uint16_t pipe)
+{
+    uint16_t pid;
+
+    pid = usb0_function_get_pid(pipe);
+
+    if ((pid & DEVDRV_USBF_PID_STALL) == DEVDRV_USBF_PID_STALL)
+    {
+        return DEVDRV_USBF_STALL;
+    }
+
+    return DEVDRV_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_sqclr
+* Description  : Sets the sequence bit of the pipe specified by the argument to
+*              : DATA0.
+* Arguments    : uint16_t pipe              ; Pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_sqclr (uint16_t pipe)
+{
+    usb0_function_set_sqclr(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_sqset
+* Description  : Sets the sequence bit of the pipe specified by the argument to
+*              : DATA1.
+* Arguments    : uint16_t pipe   ; Pipe number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_sqset (uint16_t pipe)
+{
+    usb0_function_set_sqset(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_csclr
+* Description  : CSPLIT status clear setting of sprit transaction in specified
+*              : pipe is performed.
+*              : When SQSET bit or SQCLR bit, and SQSET bit or SQCLR bit
+*              : in DCPCTR register are continuously changed (when the sequence
+*              : toggle bit of data PID is continuously changed over two or more pipes),
+*              : the access cycle with 120 ns and more than 5 cycle bus clock is necessary.
+*              : Do not set both SQCLR bit and SQSET bit to 1 at the same time.
+*              : In addition, both bits should be operated after PID is set to NAK.
+*              : However, when it is set to the isochronous transfer as the transfer type
+*              : (TYPE=11), writing in SQSET bit is disabled.
+* Arguments    : uint16_t pipe     ; Pipe number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_csclr (uint16_t pipe)
+{
+    usb0_function_set_csclr(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_set_curpipe
+* Description  : Allocates FIF0 specifed by the argument in the pipe assigned
+*              : by the argument.
+* Arguments    : uint16_t pipe      ; Pipe Number
+*              : uint16_t fifosel   ; Select FIFO
+*              : uint16_t isel      ; FIFO Access Direction
+*              : uint16_t mbw       ; FIFO Port Access Bit Width
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw)
+{
+    usb0_function_set_curpipe(pipe, fifosel, isel, mbw);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_clear_brdy_sts
+* Description  : Clear BRDY interrupt status in the pipe spceified by the argument.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_clear_brdy_sts (uint16_t pipe)
+{
+    usb0_function_clear_brdy_sts(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_clear_bemp_sts
+* Description  : Clear BEMP interrupt status in the pipe spceified by the argument.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_clear_bemp_sts (uint16_t pipe)
+{
+    usb0_function_clear_bemp_sts(pipe);
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_clear_nrdy_sts
+* Description  : Clear NRDY interrupt status in the pipe spceified by the argument.
+* Arguments    : uint16_t pipe        ; pipe Number
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_clear_nrdy_sts (uint16_t pipe)
+{
+    usb0_function_clear_nrdy_sts(pipe);
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_controlrw.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,142 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_controlrw.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: usb0_api_function_CtrlReadStart
+* Description  : Executes the USB control read transfer.
+*              : USB host controller <- USB device
+* Arguments    : uint16_t size     ; Data Size
+*              : uint8_t  *data    ; Data Address
+* Return Value : DEVDRV_USBF_WRITEEND          ; End of data write
+*              : DEVDRV_USBF_WRITESHRT         ; End of short data write
+*              : DEVDRV_USBF_WRITING           ; Continue of data write
+*              : DEVDRV_USBF_FIFOERROR         ; FIFO access error
+*******************************************************************************/
+uint16_t usb0_api_function_CtrlReadStart (uint32_t size, uint8_t * data)
+{
+    uint16_t status;
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(USB_FUNCTION_PIPE0);
+
+    g_usb0_function_data_count[USB_FUNCTION_PIPE0]   = size;
+    g_usb0_function_data_pointer[USB_FUNCTION_PIPE0] = data;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[USB_FUNCTION_PIPE0],
+                                 (uint32_t)g_usb0_function_data_pointer[USB_FUNCTION_PIPE0]);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw);
+    USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;
+
+    status = usb0_function_write_buffer_c(USB_FUNCTION_PIPE0);
+
+    /* Peripheral Control sequence */
+    switch (status)
+    {
+        case DEVDRV_USBF_WRITESHRT:                                     /* End of data write */
+        case DEVDRV_USBF_WRITEEND:                                      /* End of data write (not null) */
+        case DEVDRV_USBF_WRITING:                                       /* Continue of data write */
+            usb0_function_enable_bemp_int(USB_FUNCTION_PIPE0);          /* Enable Empty Interrupt */
+            usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);              /* Set BUF */
+        break;
+
+        case DEVDRV_USBF_FIFOERROR:                                     /* FIFO access error */
+        break;
+
+        default:
+        break;
+    }
+
+    return status;                                                      /* End or Err or Continue */
+}
+
+/*******************************************************************************
+* Function Name: usb0_api_function_CtrlWriteStart
+* Description  : Executes the USB control write transfer.
+*              : USB host controller -> USB device
+* Arguments    : uint16_t  size         ; Data Size
+*              : uint8_t  *data         ; Data Address
+* Return Value : none
+*******************************************************************************/
+void usb0_api_function_CtrlWriteStart (uint32_t size, uint8_t * data)
+{
+    uint16_t mbw;
+
+    usb0_function_set_pid_nak(USB_FUNCTION_PIPE0);
+
+    g_usb0_function_data_count[USB_FUNCTION_PIPE0]   = size;
+    g_usb0_function_data_pointer[USB_FUNCTION_PIPE0] = data;
+
+    mbw = usb0_function_get_mbw(g_usb0_function_data_count[USB_FUNCTION_PIPE0],
+                                (uint32_t)g_usb0_function_data_pointer[USB_FUNCTION_PIPE0]);
+    usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw);
+    USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;
+
+    usb0_function_enable_brdy_int(USB_FUNCTION_PIPE0);
+    usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_global.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,144 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_global.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+const uint16_t g_usb0_function_bit_set[16] =
+{
+    0x0001, 0x0002, 0x0004, 0x0008,
+    0x0010, 0x0020, 0x0040, 0x0080,
+    0x0100, 0x0200, 0x0400, 0x0800,
+    0x1000, 0x2000, 0x4000, 0x8000
+};
+
+uint32_t g_usb0_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint8_t  * g_usb0_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1];
+
+uint16_t g_usb0_function_PipeIgnore[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint16_t g_usb0_function_PipeTbl[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint16_t g_usb0_function_pipe_status[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint32_t g_usb0_function_PipeDataSize[USB_FUNCTION_MAX_PIPE_NO + 1];
+
+USB_FUNCTION_DMA_t g_usb0_function_DmaInfo[2];
+uint16_t g_usb0_function_DmaPipe[2];
+uint16_t g_usb0_function_DmaBval[2];
+uint16_t g_usb0_function_DmaStatus[2];
+
+uint16_t g_usb0_function_CtrZeroLengthFlag;
+
+//uint16_t g_usb0_function_ConfigNum;
+//uint16_t g_usb0_function_Alternate[USB_FUNCTION_ALT_NO];
+//uint16_t g_usb0_function_RemoteWakeupFlag;
+uint16_t g_usb0_function_TestModeFlag;
+uint16_t g_usb0_function_TestModeSelectors;
+
+//uint16_t g_usb0_function_ReqType;
+//uint16_t g_usb0_function_ReqTypeType;
+//uint16_t g_usb0_function_ReqTypeRecip;
+//uint16_t g_usb0_function_ReqRequest;
+//uint16_t g_usb0_function_ReqValue;
+//uint16_t g_usb0_function_ReqIndex;
+//uint16_t g_usb0_function_ReqLength;
+
+//uint16_t g_usb0_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1];
+
+uint16_t g_usb0_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint16_t g_usb0_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint16_t g_usb0_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1];
+uint16_t g_usb0_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1];
+
+
+/*******************************************************************************
+* Function Name: usb0_function_init_status
+* Description  : Initialization USB Sample Driver Variable.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void usb0_function_init_status (void)
+{
+    uint16_t pipe;
+
+    //g_usb0_function_ConfigNum         = 0;
+    //g_usb0_function_RemoteWakeupFlag  = DEVDRV_USBF_OFF;
+    g_usb0_function_TestModeFlag      = DEVDRV_USBF_OFF;
+    g_usb0_function_CtrZeroLengthFlag = 0;
+
+#if 0
+    usb0_function_clear_alt();
+#endif
+
+    for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe)
+    {
+        g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_IDLE;
+        g_usb0_function_PipeDataSize[pipe] = 0;
+        g_usb0_function_data_count[pipe]   = 0;
+
+        /* pipe configuration in usb0_function_ResetEP() */
+        g_usb0_function_pipecfg[pipe]  = 0;
+        g_usb0_function_pipebuf[pipe]  = 0;
+        g_usb0_function_pipemaxp[pipe] = 0;
+        g_usb0_function_pipeperi[pipe] = 0;
+    }
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_sig.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,330 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_sig.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+static void usb0_function_EnableINTModule(void);
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: usb0_function_InitModule
+* Description  : Initializes the USB module in the USB function mode.
+* Arguments    : uint16_t mode  ; USB_FUNCTION_HIGH_SPEED ; Hi-Speed Mode
+*              :                ; other                   ; Full-speed Mode
+* Return Value : none
+*******************************************************************************/
+void usb0_function_InitModule (uint16_t mode)
+{
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        0,
+                        USB_SYSCFG_DCFM_SHIFT,
+                        USB_SYSCFG_DCFM);           /* USB function */
+
+    /* USB module operation enabled     */
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        1,
+                        USB_SYSCFG_USBE_SHIFT,
+                        USB_SYSCFG_USBE);
+
+    if (mode == USB_FUNCTION_HIGH_SPEED)
+    {
+        RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                            1,
+                            USB_SYSCFG_HSE_SHIFT,
+                            USB_SYSCFG_HSE);        /* Hi-Speed Mode */
+    }
+    else
+    {
+        RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                            0,
+                            USB_SYSCFG_HSE_SHIFT,
+                            USB_SYSCFG_HSE);
+    }
+
+    /* for power-on                     */
+    if (usb0_function_CheckVBUStaus() == DEVDRV_USBF_ON)
+    {
+        usb0_function_EnableINTModule();            /* Interrupt Enable         */
+        usb0_function_USB_FUNCTION_Attach();        /* pull-up D+ and open D-   */
+    }
+    else
+    {
+        usb0_function_USB_FUNCTION_Detach();        /* USB Detach               */
+                                                    /* with Interrupt Enable    */
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_CheckVBUStaus
+* Description  : Checks the USB-VBUS state to returns the connection state to
+*              : the USB host.
+* Arguments    : none
+* Return Value : DEVDRV_USBF_ON     :   VBUS ON
+*              : DEVDRV_USBF_OFF    :   VBUS OFF
+*******************************************************************************/
+uint16_t usb0_function_CheckVBUStaus (void)
+{
+    uint16_t buf1;
+    uint16_t buf2;
+    uint16_t buf3;
+
+    /* monitor VBUS pins */
+    do
+    {
+        buf1 = RZA_IO_RegRead_16(&USB200.INTSTS0,
+                                USB_INTSTS0_VBSTS_SHIFT,
+                                USB_INTSTS0_VBSTS);
+        Userdef_USB_usb0_function_delay_10us(1);
+        buf2 = RZA_IO_RegRead_16(&USB200.INTSTS0,
+                                USB_INTSTS0_VBSTS_SHIFT,
+                                USB_INTSTS0_VBSTS);
+        Userdef_USB_usb0_function_delay_10us(1);
+        buf3 = RZA_IO_RegRead_16(&USB200.INTSTS0,
+                                USB_INTSTS0_VBSTS_SHIFT,
+                                USB_INTSTS0_VBSTS);
+    } while ((buf1 != buf2) || (buf2 != buf3));
+
+    if (buf1 == DEVDRV_USBF_OFF)
+    {
+        return DEVDRV_USBF_OFF;         /* detach */
+    }
+
+    return DEVDRV_USBF_ON;              /* attach */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_USB_FUNCTION_Attach
+* Description  : Connects to the USB host controller.
+*              : This function pulls up D+.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void usb0_function_USB_FUNCTION_Attach (void)
+{
+    Userdef_USB_usb0_function_attach();
+
+    Userdef_USB_usb0_function_delay_xms(10);
+
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        1,
+                        USB_SYSCFG_DPRPU_SHIFT,
+                        USB_SYSCFG_DPRPU);      /* Pull-up D+ and open D- */
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_USB_FUNCTION_Detach
+* Description  : Disconnects from the USB host controller.
+*              : This function opens D+/D-.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void usb0_function_USB_FUNCTION_Detach (void)
+{
+    uint16_t pipe;
+
+    Userdef_USB_usb0_function_detach();
+
+    for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe)
+    {
+        if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_IDLE)
+        {
+            usb0_function_stop_transfer(pipe);
+        }
+    }
+
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        0,
+                        USB_SYSCFG_DPRPU_SHIFT,
+                        USB_SYSCFG_DPRPU);                  /* open D+ and D- */
+
+    /* Detach Recovery */
+    Userdef_USB_usb0_function_delay_500ns();                /* need 1us=500ns * 2 wait */
+    Userdef_USB_usb0_function_delay_500ns();
+
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        1,
+                        USB_SYSCFG_DCFM_SHIFT,
+                        USB_SYSCFG_DCFM);
+    Userdef_USB_usb0_function_delay_500ns();                /* need 100ns wait but 500ns S/W wait */
+
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        0,
+                        USB_SYSCFG_DCFM_SHIFT,
+                        USB_SYSCFG_DCFM);
+
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        0,
+                        USB_SYSCFG_USBE_SHIFT,
+                        USB_SYSCFG_USBE);       /* soft reset module */
+    Userdef_USB_usb0_function_delay_500ns();
+
+    RZA_IO_RegWrite_16(&USB200.SYSCFG0,
+                        1,
+                        USB_SYSCFG_USBE_SHIFT,
+                        USB_SYSCFG_USBE);
+
+    usb0_function_EnableINTModule();            /* Interrupt Enable */
+}
+
+/*******************************************************************************
+* Function Name: usb0_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
+*******************************************************************************/
+#if 0	/*The USBHAL in mbed does not need this function*/
+void usb0_function_USB_FUNCTION_BusReset (void)
+{
+    usb0_function_init_status();                                    /* memory clear */
+
+    if (usb0_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED)
+    {
+        usb0_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED);     /* Device Descriptor reset */
+    }
+    else
+    {
+        usb0_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED);     /* Device Descriptor reset */
+    }
+
+    usb0_function_ResetDCP();                                       /* Default Control PIPE reset */
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_USB_FUNCTION_Resume
+* Description  : This function is executed when the USB device detects a resume
+*              : signal.
+*              : The USB sample driver does not operate for this function.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+#if 0	/*The USBHAL in mbed does not need this function*/
+void usb0_function_USB_FUNCTION_Resume (void)
+{
+    /* NOP */
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_USB_FUNCTION_Suspend
+* Description  : This function is executed when the USB device detects a suspend
+*              : signal.
+*              : The USB sample driver does not operate for this function.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+#if 0	/*The USBHAL in mbed does not need this function*/
+void usb0_function_USB_FUNCTION_Suspend (void)
+{
+    /* NOP */
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_USB_FUNCTION_TestMode
+* Description  : This function is executed when the USB device is transitioned U
+*              : to TEST_MODE by the USB standard request.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void usb0_function_USB_FUNCTION_TestMode (void)
+{
+    switch (g_usb0_function_TestModeSelectors & USB_FUNCTION_FUNCTION_TEST_SELECT)
+    {
+        case USB_FUNCTION_FUNCTION_TEST_J:
+        case USB_FUNCTION_FUNCTION_TEST_K:
+        case USB_FUNCTION_FUNCTION_TEST_SE0_NAK:
+        case USB_FUNCTION_FUNCTION_TEST_PACKET:
+            RZA_IO_RegWrite_16(&USB200.TESTMODE,
+                                (g_usb0_function_TestModeSelectors >> 8),
+                                USB_TESTMODE_UTST_SHIFT,
+                                USB_TESTMODE_UTST);
+        break;
+
+        case USB_FUNCTION_FUNCTION_TEST_FORCE_ENABLE:
+        default:
+        break;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_EnableINTModule
+* Description  : Enables USB interrupt.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_EnableINTModule (void)
+{
+    uint16_t buf;
+
+    buf  = USB200.INTENB0;
+    buf |= (USB_FUNCTION_BITVBSE | USB_FUNCTION_BITDVSE | USB_FUNCTION_BITCTRE |
+             USB_FUNCTION_BITBEMPE | USB_FUNCTION_BITNRDYE | USB_FUNCTION_BITBRDYE);
+    USB200.INTENB0 = buf;
+
+    usb0_function_enable_bemp_int(USB_FUNCTION_PIPE0);
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_sub.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,453 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_sub.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include "usb0_function.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+#if 0
+extern const uint16_t *g_usb0_function_EndPntPtr[];
+extern uint8_t         g_usb0_function_DeviceDescriptor[];
+extern uint8_t        *g_usb0_function_ConfigurationPtr[];
+#endif
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: usb0_function_ResetDCP
+* Description  : Initializes the default control pipe(DCP).
+* Outline      : Reset default control pipe
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void usb0_function_ResetDCP (void)
+{
+    USB200.DCPCFG  = 0;
+#if 0
+    USB200.DCPMAXP = g_usb0_function_DeviceDescriptor[7];
+#else
+    USB200.DCPMAXP = 64;
+#endif
+
+    USB200.CFIFOSEL  = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
+    USB200.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
+    USB200.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_ResetEP
+* Description  : Initializes the end point.
+* Arguments    : uint16_t num          ; Configuration Number
+* Return Value : none
+*******************************************************************************/
+#if 0
+void usb0_function_ResetEP (uint16_t num)
+{
+    uint16_t   pipe;
+    uint16_t   ep;
+    uint16_t   index;
+    uint16_t   buf;
+    uint16_t * tbl;
+
+    tbl = (uint16_t *)(g_usb0_function_EndPntPtr[num - 1]);
+
+    for (ep = 1; ep <= USB_FUNCTION_MAX_EP_NO; ++ep)
+    {
+        if (g_usb0_function_EPTableIndex[ep] != USB_FUNCTION_EP_ERROR)
+        {
+            index = (uint16_t)(USB_FUNCTION_EPTABLE_LENGTH * g_usb0_function_EPTableIndex[ep]);
+            pipe  = (uint16_t)(tbl[index + 0] & USB_FUNCTION_BITCURPIPE);
+
+            g_usb0_function_PipeTbl[pipe] = (uint16_t)( ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) << 3) |
+                                                         ep                                             |
+                                                         (tbl[index + 0] & USB_FUNCTION_FIFO_USE)          );
+
+            if ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) == USB_FUNCTION_DIR_P_OUT)
+            {
+                tbl[index + 1] |= USB_FUNCTION_SHTNAKON;
+#ifdef  __USB_DMA_BFRE_ENABLE__
+                /* this routine cannnot be perfomred if read operation is executed in buffer size */
+                if (((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) ||
+                    ((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA))
+                {
+                    tbl[index + 1] |= USB_FUNCTION_BFREON;
+                }
+#endif
+            }
+
+            /* Interrupt Disable */
+            buf  = USB200.BRDYENB;
+            buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
+            USB200.BRDYENB = buf;
+            buf  = USB200.NRDYENB;
+            buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
+            USB200.NRDYENB = buf;
+            buf  = USB200.BEMPENB;
+            buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
+            USB200.BEMPENB = buf;
+
+            usb0_function_set_pid_nak(pipe);
+
+            /* CurrentPIPE Clear */
+            if (RZA_IO_RegRead_16(&USB200.CFIFOSEL,
+                                    USB_CFIFOSEL_CURPIPE_SHIFT,
+                                    USB_CFIFOSEL_CURPIPE) == pipe)
+            {
+                RZA_IO_RegWrite_16(&USB200.CFIFOSEL,
+                                    0,
+                                    USB_CFIFOSEL_CURPIPE_SHIFT,
+                                    USB_CFIFOSEL_CURPIPE);
+            }
+
+            if (RZA_IO_RegRead_16(&USB200.D0FIFOSEL,
+                                    USB_DnFIFOSEL_CURPIPE_SHIFT,
+                                    USB_DnFIFOSEL_CURPIPE) == pipe)
+            {
+                RZA_IO_RegWrite_16(&USB200.D0FIFOSEL,
+                                    0,
+                                    USB_DnFIFOSEL_CURPIPE_SHIFT,
+                                    USB_DnFIFOSEL_CURPIPE);
+            }
+
+            if (RZA_IO_RegRead_16(&USB200.D1FIFOSEL,
+                                    USB_DnFIFOSEL_CURPIPE_SHIFT,
+                                    USB_DnFIFOSEL_CURPIPE) == pipe)
+            {
+                RZA_IO_RegWrite_16(&USB200.D1FIFOSEL,
+                                    0,
+                                    USB_DnFIFOSEL_CURPIPE_SHIFT,
+                                    USB_DnFIFOSEL_CURPIPE);
+            }
+
+            /* PIPE Configuration */
+            USB200.PIPESEL  = pipe;
+            USB200.PIPECFG  = tbl[index + 1];
+            USB200.PIPEBUF  = tbl[index + 2];
+            USB200.PIPEMAXP = tbl[index + 3];
+            USB200.PIPEPERI = tbl[index + 4];
+
+            g_usb0_function_pipecfg[pipe]  = tbl[index + 1];
+            g_usb0_function_pipebuf[pipe]  = tbl[index + 2];
+            g_usb0_function_pipemaxp[pipe] = tbl[index + 3];
+            g_usb0_function_pipeperi[pipe] = tbl[index + 4];
+
+            /* Buffer Clear */
+            usb0_function_set_sqclr(pipe);
+            usb0_function_aclrm(pipe);
+
+            /* init Global */
+            g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_IDLE;
+            g_usb0_function_PipeDataSize[pipe] = 0;
+        }
+    }
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_EpToPipe
+* Description  : Returns the pipe which end point specified by the argument is
+*              : allocated to.
+* Arguments    : uint16_t ep       ; Direction + Endpoint Number
+* Return Value : USB_FUNCTION_EP_ERROR         : Error
+*              : Others           : Pipe Number
+*******************************************************************************/
+uint16_t usb0_function_EpToPipe (uint16_t ep)
+{
+    uint16_t pipe;
+
+    for (pipe = 1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
+    {
+        if ((g_usb0_function_PipeTbl[pipe] & 0x00ff) == ep)
+        {
+            return pipe;
+        }
+    }
+
+    return USB_FUNCTION_EP_ERROR;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_InitEPTable
+* Description  : Sets the end point by the Alternate setting value of the
+*              : configuration number and the interface number specified by the
+*              : argument.
+* Arguments    : uint16_t Con_Num       ; Configuration Number
+*              : uint16_t Int_Num       ; Interface Number
+*              : uint16_t Alt_Num       ; Alternate Setting
+* Return Value : none
+*******************************************************************************/
+#if 0
+void usb0_function_InitEPTable (uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num)
+{
+    uint8_t  * ptr;
+    uint16_t   point_interface;
+    uint16_t   point_endpoint;
+    uint16_t   length;
+    uint16_t   start;
+    uint16_t   numbers;
+    uint16_t   endpoint;
+
+    ptr = (uint8_t *)g_usb0_function_ConfigurationPtr[Con_Num - 1];
+    point_interface = *ptr;
+    length = (uint16_t)((uint16_t)*(ptr + 3) << 8 | (uint16_t)*(ptr + 2));
+    ptr  += *ptr;
+    start   = 0;
+    numbers = 0;
+    point_endpoint = 0;
+
+    for (; point_interface < length;)
+    {
+        switch (*(ptr + 1))                                     /* Descriptor Type ? */
+        {
+            case USB_FUNCTION_DT_INTERFACE:                     /* Interface */
+                if ((*(ptr + 2) == Int_Num) && (*(ptr + 3) == Alt_Num))
+                {
+                    numbers = *(ptr + 4);
+                }
+                else
+                {
+                    start  += *(ptr + 4);
+                }
+                point_interface += *ptr;
+                ptr += *ptr;
+            break;
+
+            case USB_FUNCTION_DT_ENDPOINT:                      /* Endpoint */
+                if (point_endpoint < numbers)
+                {
+                    endpoint = (uint16_t)(*(ptr + 2) & 0x0f);
+                    g_usb0_function_EPTableIndex[endpoint] = (uint16_t)(start + point_endpoint);
+                    ++point_endpoint;
+                }
+                point_interface += *ptr;
+                ptr += *ptr;
+            break;
+
+            case USB_FUNCTION_DT_DEVICE:                        /* Device */
+            case USB_FUNCTION_DT_CONFIGURATION:                 /* Configuration */
+            case USB_FUNCTION_DT_STRING:                        /* String */
+            default:                                            /* Class, Vendor, else */
+                point_interface += *ptr;
+                ptr += *ptr;
+            break;
+        }
+    }
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_GetConfigNum
+* Description  : Returns the number of configuration referring to the number of
+*              : configuration described in the device descriptor.
+* Arguments    : none
+* Return Value : Number of possible configurations (bNumConfigurations).
+*******************************************************************************/
+#if 0
+uint16_t usb0_function_GetConfigNum (void)
+{
+    return (uint16_t)g_usb0_function_DeviceDescriptor[17];
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_GetInterfaceNum
+* Description  : Returns the number of interface referring to the number of
+*              : interface described in the configuration descriptor.
+* Arguments    : uint16_t num       ; Configuration Number
+* Return Value : Number of this interface (bNumInterfaces).
+*******************************************************************************/
+#if 0
+uint16_t usb0_function_GetInterfaceNum (uint16_t num)
+{
+    return (uint16_t)(*(g_usb0_function_ConfigurationPtr[num - 1] + 4));
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_GetAltNum
+* Description  : Returns the Alternate setting value of the configuration number
+*              : and the interface number specified by the argument.
+* Arguments    : uint16_t Con_Num       ; Configuration Number
+*              : uint16_t Int_Num       ; Interface Number
+* Return Value : Value used to select this alternate setting(bAlternateSetting).
+*******************************************************************************/
+#if 0
+uint16_t usb0_function_GetAltNum (uint16_t Con_Num, uint16_t Int_Num)
+{
+    uint8_t  * ptr;
+    uint16_t   point;
+    uint16_t   alt_num = 0;
+    uint16_t   length;
+
+    ptr = (uint8_t *)(g_usb0_function_ConfigurationPtr[Con_Num - 1]);
+    point = ptr[0];
+    ptr  += ptr[0];                                 /* InterfaceDescriptor[0] */
+    length  = (uint16_t)(*(g_usb0_function_ConfigurationPtr[Con_Num - 1] + 2));
+    length |= (uint16_t)((uint16_t)(*(g_usb0_function_ConfigurationPtr[Con_Num - 1] + 3)) << 8);
+
+    for (; point < length;)                                 /* Search Descriptor Table size */
+    {
+        switch (ptr[1])                                     /* Descriptor Type ? */
+        {
+            case USB_FUNCTION_DT_INTERFACE:                 /* Interface */
+                if (Int_Num == ptr[2])
+                {
+                    alt_num = (uint16_t)ptr[3];             /* Alternate Number count */
+                }
+                point += ptr[0];
+                ptr += ptr[0];
+            break;
+
+            case USB_FUNCTION_DT_DEVICE:                    /* Device */
+            case USB_FUNCTION_DT_CONFIGURATION:             /* Configuration */
+            case USB_FUNCTION_DT_STRING:                    /* String */
+            case USB_FUNCTION_DT_ENDPOINT:                  /* Endpoint */
+            default:                                        /* Class, Vendor, else */
+                point += ptr[0];
+                ptr   += ptr[0];
+            break;
+        }
+    }
+    return alt_num;
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_CheckRemoteWakeup
+* Description  : Returns the result of the remote wake up function is supported
+*              : or not referring to the configuration descriptor.
+* Arguments    : none
+* Return Value : DEVDRV_USBF_ON     :   Support Remote Wakeup
+*              : DEVDRV_USBF_OFF    :   not Support Remote Wakeup
+*******************************************************************************/
+#if 0
+uint16_t usb0_function_CheckRemoteWakeup (void)
+{
+    uint8_t atr;
+
+    if (g_usb0_function_ConfigNum == 0)
+    {
+        return DEVDRV_USBF_OFF;
+    }
+
+    atr = *(g_usb0_function_ConfigurationPtr[g_usb0_function_ConfigNum - 1] + 7);
+
+    if (atr & USB_FUNCTION_CF_RWUP)
+    {
+        return DEVDRV_USBF_ON;
+    }
+
+    return DEVDRV_USBF_OFF;
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_alt
+* Description  : Initializes the Alternate setting area.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+#if 0
+void usb0_function_clear_alt (void)
+{
+    int i;
+
+    for (i = 0; i < USB_FUNCTION_ALT_NO; ++i)
+    {
+        g_usb0_function_Alternate[i] = 0;                           /* Alternate */
+    }
+}
+#endif
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_pipe_tbl
+* Description  : Initializes pipe definition table.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void usb0_function_clear_pipe_tbl (void)
+{
+    int pipe;
+
+    for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe)
+    {
+        g_usb0_function_PipeTbl[pipe] = 0;
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_clear_ep_table_index
+* Description  : Initializes the end point table index.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+#if 0
+void usb0_function_clear_ep_table_index (void)
+{
+    int ep;
+
+    for (ep = 0; ep <= USB_FUNCTION_MAX_EP_NO; ++ep)
+    {
+        g_usb0_function_EPTableIndex[ep] = USB_FUNCTION_EP_ERROR;
+    }
+}
+#endif
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/rza_io_regrw.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,200 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name   : rza_io_regrw.c
+* $Rev: 1121 $
+* $Date:: 2014-08-06 17:09:53 +0900#$
+* Description : Low level register read/write
+*******************************************************************************/
+
+/******************************************************************************
+Includes   <System Includes> , "Project Includes"
+******************************************************************************/
+#include "r_typedefs.h"
+
+#ifdef __CC_ARM
+#pragma arm section code   = "CODE_IO_REGRW"
+#pragma arm section rodata = "CONST_IO_REGRW"
+#pragma arm section rwdata = "DATA_IO_REGRW"
+#pragma arm section zidata = "BSS_IO_REGRW"
+#endif
+
+/******************************************************************************
+Typedef definitions
+******************************************************************************/
+
+
+/******************************************************************************
+Macro definitions
+******************************************************************************/
+
+
+/******************************************************************************
+Imported global variables and functions (from other files)
+******************************************************************************/
+
+
+/******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+******************************************************************************/
+
+
+/******************************************************************************
+Private global variables and functions
+******************************************************************************/
+
+
+/******************************************************************************
+* Function Name: RZA_IO_RegWrite_8
+* Description  : IO register 8-bit write
+* Arguments    : volatile uint8_t * ioreg : IO register for writing
+*              :                          : Use register definition name of the
+*              :                          : iodefine.h
+*              : uint8_t write_value      : Write value for the IO register
+*              : uint8_t shift            : The number of left shifts to the 
+*              :                          : target bit
+*              : uint8_t mask             : Mask value for the IO register
+*              :                          : (Target bit : "1")
+* Return Value : None
+******************************************************************************/
+void RZA_IO_RegWrite_8(volatile uint8_t * ioreg, uint8_t write_value, uint8_t shift, uint8_t mask)
+{
+    uint8_t reg_value;
+
+    reg_value = *ioreg;                                         /* Read from register */
+    reg_value = (reg_value & (~mask)) | (write_value << shift); /* Modify value       */
+    *ioreg    = reg_value;                                      /* Write to register  */
+}
+
+/******************************************************************************
+* Function Name: RZA_IO_RegWrite_16
+* Description  : IO register 16-bit write
+* Arguments    : volatile uint16_t * ioreg : IO register for writing
+*              :                           : Use register definition name of the
+*              :                           : iodefine.h
+*              : uint16_t write_value      : Write value for the IO register
+*              : uint16_t shift            : The number of left shifts to the 
+*              :                           : target bit
+*              : uint16_t mask             : Mask value for the IO register
+*              :                           : (Target bit : "1")
+* Return Value : None
+******************************************************************************/
+void RZA_IO_RegWrite_16(volatile uint16_t * ioreg, uint16_t write_value, uint16_t shift, uint16_t mask)
+{
+    uint16_t reg_value;
+
+    reg_value = *ioreg;                                         /* Read from register */
+    reg_value = (reg_value & (~mask)) | (write_value << shift); /* Modify value       */
+    *ioreg    = reg_value;                                      /* Write to register  */
+}
+
+/******************************************************************************
+* Function Name: RZA_IO_RegWrite_32
+* Description  : IO register 32-bit write
+* Arguments    : volatile uint32_t * ioreg : IO register for writing
+*              :                           : Use register definition name of the
+*              :                           : iodefine.h
+*              : uint32_t write_value      : Write value for the IO register
+*              : uint32_t shift            : The number of left shifts to the 
+*              :                           : target bit
+*              : uint32_t mask             : Mask value for the IO register
+*              :                           : (Target bit : "1")
+* Return Value : None
+******************************************************************************/
+void RZA_IO_RegWrite_32(volatile uint32_t * ioreg, uint32_t write_value, uint32_t shift, uint32_t mask)
+{
+    uint32_t reg_value;
+
+    reg_value = *ioreg;                                         /* Read from register */
+    reg_value = (reg_value & (~mask)) | (write_value << shift); /* Modify value       */
+    *ioreg    = reg_value;                                      /* Write to register  */
+}
+
+/******************************************************************************
+* Function Name: RZA_IO_RegRead_8
+* Description  : IO register 8-bit read
+* Arguments    : volatile uint8_t * ioreg : IO register for reading
+*              :                          : Use register definition name of the 
+*              :                          : iodefine.h
+*              : uint8_t shift            : The number of right shifts to the 
+*              :                          : target bit
+*              : uint8_t mask             : Mask bit for the IO register
+*              :                          : (Target bit: "1")
+* Return Value : uint8_t : Value of the obtained target bit
+******************************************************************************/
+uint8_t RZA_IO_RegRead_8(volatile uint8_t * ioreg, uint8_t shift, uint8_t mask)
+{
+    uint8_t reg_value;
+
+    reg_value = *ioreg;                         /* Read from register            */
+    reg_value = (reg_value & mask) >> shift;    /* Clear other bit and Bit shift */
+
+    return reg_value;
+}
+
+/******************************************************************************
+* Function Name: RZA_IO_RegRead_16
+* Description  : IO register 16-bit read
+* Arguments    : volatile uint16_t * ioreg : IO register for reading
+*              :                           : Use register definition name of the 
+*              :                           : iodefine.h
+*              : uint16_t shift            : The number of right shifts to the 
+*              :                           : target bit
+*              : uint16_t mask             : Mask bit for the IO register
+*              :                           : (Target bit: "1")
+* Return Value : uint16_t : Value of the obtained target bit
+******************************************************************************/
+uint16_t RZA_IO_RegRead_16(volatile uint16_t * ioreg, uint16_t shift, uint16_t mask)
+{
+    uint16_t reg_value;
+
+    reg_value = *ioreg;                         /* Read from register            */
+    reg_value = (reg_value & mask) >> shift;    /* Clear other bit and Bit shift */
+
+    return reg_value;
+}
+
+/******************************************************************************
+* Function Name: RZA_IO_RegRead_32
+* Description  : IO register 32-bit read
+* Arguments    : volatile uint32_t * ioreg : IO register for reading
+*              :                           : Use register definition name of the 
+*              :                           : iodefine.h
+*              : uint32_t shift            : The number of right shifts to the 
+*              :                           : target bit
+*              : uint32_t mask             : Mask bit for the IO register
+*              :                           : (Target bit: "1")
+* Return Value : uint32_t : Value of the obtained target bit
+******************************************************************************/
+uint32_t RZA_IO_RegRead_32(volatile uint32_t * ioreg, uint32_t shift, uint32_t mask)
+{
+    uint32_t reg_value;
+
+    reg_value = *ioreg;                         /* Read from register            */
+    reg_value = (reg_value & mask) >> shift;    /* Clear other bit and Bit shift */
+
+    return reg_value;
+}
+
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/usb0_function_dmacdrv.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,698 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_dmacdrv.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include <stdio.h>
+#include "r_typedefs.h"
+#include "iodefine.h"
+#include "rza_io_regrw.h"
+#include "usb0_function_dmacdrv.h"
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+#define DMAC_INDEFINE   (255)       /* Macro definition when REQD bit is not used */
+
+/* ==== Request setting information for on-chip peripheral module ==== */
+typedef enum dmac_peri_req_reg_type
+{
+    DMAC_REQ_MID,
+    DMAC_REQ_RID,
+    DMAC_REQ_AM,
+    DMAC_REQ_LVL,
+    DMAC_REQ_REQD
+} dmac_peri_req_reg_type_t;
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+/* ==== Prototype declaration ==== */
+
+/* ==== Global variable ==== */
+/* On-chip peripheral module request setting table */
+static const uint8_t usb0_function_dmac_peri_req_init_table[8][5] =
+{
+    /* MID,RID,AM,LVL,REQD */
+    {32, 3, 2, 1, 1},    /* USB_0 channel 0 transmit FIFO empty */
+    {32, 3, 2, 1, 0},    /* USB_0 channel 0 receive FIFO full   */
+    {33, 3, 2, 1, 1},    /* USB_0 channel 1 transmit FIFO empty */
+    {33, 3, 2, 1, 0},    /* USB_0 channel 1 receive FIFO full   */
+    {34, 3, 2, 1, 1},    /* USB_1 channel 0 transmit FIFO empty */
+    {34, 3, 2, 1, 0},    /* USB_1 channel 0 receive FIFO full   */
+    {35, 3, 2, 1, 1},    /* USB_1 channel 1 transmit FIFO empty */
+    {35, 3, 2, 1, 0},    /* USB_1 channel 1 receive FIFO full   */
+};
+
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC1_PeriReqInit
+* Description  : Sets the register mode for DMA mode and the on-chip peripheral
+*              : module request for transfer request for DMAC channel 1.
+*              : Executes DMAC initial setting using the DMA information
+*              : specified by the argument *trans_info and the enabled/disabled
+*              : continuous transfer specified by the argument continuation.
+*              : Registers DMAC channel 1 interrupt handler function and sets
+*              : the interrupt priority level. Then enables transfer completion
+*              : interrupt.
+* Arguments    : dmac_transinfo_t *trans_info   : Setting information to DMAC register
+*              : uint32_t          dmamode      : DMA mode (only for DMAC_MODE_REGISTER)
+*              : uint32_t          continuation : Set continuous transfer to be valid
+*              :                                  after DMA transfer has been completed
+*              :             DMAC_SAMPLE_CONTINUATION : Execute continuous transfer
+*              :             DMAC_SAMPLE_SINGLE       : Do not execute continuous transfer
+*              : uint32_t request_factor        : Factor for on-chip peripheral module request
+*              :             DMAC_REQ_OSTM0TINT       : OSTM_0 compare match
+*              :             DMAC_REQ_OSTM1TINT       : OSTM_1 compare match
+*              :             DMAC_REQ_TGI0A           : MTU2_0 input capture/compare match
+*              :                  :
+*              : uint32_t          req_direction: Setting value of CHCFG_n register REQD bit
+* Return Value : none
+*******************************************************************************/
+void usb0_function_DMAC1_PeriReqInit (const dmac_transinfo_t * trans_info,
+                                      uint32_t dmamode, uint32_t continuation,
+                                      uint32_t request_factor, uint32_t req_direction)
+{
+    /* ==== Register mode ==== */
+    if (DMAC_MODE_REGISTER == dmamode)
+    {
+        /* ==== Next0 register set ==== */
+        DMAC1.N0SA_n = trans_info->src_addr;        /* Start address of transfer source      */
+        DMAC1.N0DA_n = trans_info->dst_addr;        /* Start address of transfer destination */
+        DMAC1.N0TB_n = trans_info->count;           /* Total transfer byte count             */
+
+        /* DAD : Transfer destination address counting direction */
+        /* SAD : Transfer source address counting direction      */
+        /* DDS : Transfer destination transfer size              */
+        /* SDS : Transfer source transfer size                   */
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            trans_info->daddr_dir,
+                            DMAC1_CHCFG_n_DAD_SHIFT,
+                            DMAC1_CHCFG_n_DAD);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            trans_info->saddr_dir,
+                            DMAC1_CHCFG_n_SAD_SHIFT,
+                            DMAC1_CHCFG_n_SAD);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            trans_info->dst_size,
+                            DMAC1_CHCFG_n_DDS_SHIFT,
+                            DMAC1_CHCFG_n_DDS);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            trans_info->src_size,
+                            DMAC1_CHCFG_n_SDS_SHIFT,
+                            DMAC1_CHCFG_n_SDS);
+
+        /* DMS  : Register mode                            */
+        /* RSEL : Select Next0 register set                */
+        /* SBE  : No discharge of buffer data when aborted */
+        /* DEM  : No DMA interrupt mask                    */
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            0,
+                            DMAC1_CHCFG_n_DMS_SHIFT,
+                            DMAC1_CHCFG_n_DMS);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            0,
+                            DMAC1_CHCFG_n_RSEL_SHIFT,
+                            DMAC1_CHCFG_n_RSEL);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            0,
+                            DMAC1_CHCFG_n_SBE_SHIFT,
+                            DMAC1_CHCFG_n_SBE);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            0,
+                            DMAC1_CHCFG_n_DEM_SHIFT,
+                            DMAC1_CHCFG_n_DEM);
+
+        /* ---- Continuous transfer ---- */
+        if (DMAC_SAMPLE_CONTINUATION == continuation)
+        {
+            /* REN : Execute continuous transfer                         */
+            /* RSW : Change register set when DMA transfer is completed. */
+            RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                                1,
+                                DMAC1_CHCFG_n_REN_SHIFT,
+                                DMAC1_CHCFG_n_REN);
+            RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                                1,
+                                DMAC1_CHCFG_n_RSW_SHIFT,
+                                DMAC1_CHCFG_n_RSW);
+        }
+        /* ---- Single transfer ---- */
+        else
+        {
+            /* REN : Do not execute continuous transfer                         */
+            /* RSW : Do not change register set when DMA transfer is completed. */
+            RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                                0,
+                                DMAC1_CHCFG_n_REN_SHIFT,
+                                DMAC1_CHCFG_n_REN);
+            RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                                0,
+                                DMAC1_CHCFG_n_RSW_SHIFT,
+                                DMAC1_CHCFG_n_RSW);
+        }
+
+        /* TM  : Single transfer                          */
+        /* SEL : Channel setting                          */
+        /* HIEN, LOEN : On-chip peripheral module request */
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            0,
+                            DMAC1_CHCFG_n_TM_SHIFT,
+                            DMAC1_CHCFG_n_TM);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            1,
+                            DMAC1_CHCFG_n_SEL_SHIFT,
+                            DMAC1_CHCFG_n_SEL);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            1,
+                            DMAC1_CHCFG_n_HIEN_SHIFT,
+                            DMAC1_CHCFG_n_HIEN);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            0,
+                            DMAC1_CHCFG_n_LOEN_SHIFT,
+                            DMAC1_CHCFG_n_LOEN);
+
+        /* ---- Set factor by specified on-chip peripheral module request ---- */
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM],
+                            DMAC1_CHCFG_n_AM_SHIFT,
+                            DMAC1_CHCFG_n_AM);
+        RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL],
+                            DMAC1_CHCFG_n_LVL_SHIFT,
+                            DMAC1_CHCFG_n_LVL);
+
+        if (usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE)
+        {
+            RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                                usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD],
+                                DMAC1_CHCFG_n_REQD_SHIFT,
+                                DMAC1_CHCFG_n_REQD);
+        }
+        else
+        {
+            RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
+                                req_direction,
+                                DMAC1_CHCFG_n_REQD_SHIFT,
+                                DMAC1_CHCFG_n_REQD);
+        }
+
+        RZA_IO_RegWrite_32(&DMAC01.DMARS,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID],
+                            DMAC01_DMARS_CH1_RID_SHIFT,
+                            DMAC01_DMARS_CH1_RID);
+        RZA_IO_RegWrite_32(&DMAC01.DMARS,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID],
+                            DMAC01_DMARS_CH1_MID_SHIFT,
+                            DMAC01_DMARS_CH1_MID);
+
+        /* PR : Round robin mode */
+        RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7,
+                            1,
+                            DMAC07_DCTRL_0_7_PR_SHIFT,
+                            DMAC07_DCTRL_0_7_PR);
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC1_Open
+* Description  : Enables DMAC channel 1 transfer.
+* Arguments    : uint32_t req : DMAC request mode
+* Return Value :  0 : Succeeded in enabling DMA transfer
+*              : -1 : Failed to enable DMA transfer (due to DMA operation)
+*******************************************************************************/
+int32_t usb0_function_DMAC1_Open (uint32_t req)
+{
+    int32_t ret;
+    volatile uint8_t dummy;
+
+    /* Transferable? */
+    if ((0 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
+                                DMAC1_CHSTAT_n_EN_SHIFT,
+                                DMAC1_CHSTAT_n_EN)) &&
+        (0 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
+                                DMAC1_CHSTAT_n_TACT_SHIFT,
+                                DMAC1_CHSTAT_n_TACT)))
+    {
+        /* Clear Channel Status Register */
+        RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
+                            1,
+                            DMAC1_CHCTRL_n_SWRST_SHIFT,
+                            DMAC1_CHCTRL_n_SWRST);
+        dummy = RZA_IO_RegRead_32(&DMAC1.CHCTRL_n,
+                                DMAC1_CHCTRL_n_SWRST_SHIFT,
+                                DMAC1_CHCTRL_n_SWRST);
+        /* Enable DMA transfer */
+        RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
+                            1,
+                            DMAC1_CHCTRL_n_SETEN_SHIFT,
+                            DMAC1_CHCTRL_n_SETEN);
+
+        /* ---- Request by software ---- */
+        if (DMAC_REQ_MODE_SOFT == req)
+        {
+            /* DMA transfer Request by software */
+            RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
+                                1,
+                                DMAC1_CHCTRL_n_STG_SHIFT,
+                                DMAC1_CHCTRL_n_STG);
+        }
+
+        ret = 0;
+    }
+    else
+    {
+        ret = -1;
+    }
+
+    return ret;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC1_Close
+* Description  : Aborts DMAC channel 1 transfer. Returns the remaining transfer
+*              : byte count at the time of DMA transfer abort to the argument
+*              : *remain.
+* Arguments    : uint32_t * remain : Remaining transfer byte count when
+*              :                   : DMA transfer is aborted
+* Return Value : none
+*******************************************************************************/
+void usb0_function_DMAC1_Close (uint32_t * remain)
+{
+
+    /* ==== Abort transfer ==== */
+    RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
+                        1,
+                        DMAC1_CHCTRL_n_CLREN_SHIFT,
+                        DMAC1_CHCTRL_n_CLREN);
+
+    while (1 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
+                                DMAC1_CHSTAT_n_TACT_SHIFT,
+                                DMAC1_CHSTAT_n_TACT))
+    {
+        /* Loop until transfer is aborted */
+    }
+
+    while (1 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
+                                DMAC1_CHSTAT_n_EN_SHIFT,
+                                DMAC1_CHSTAT_n_EN))
+    {
+        /* Loop until 0 is set in EN before checking the remaining transfer byte count */
+    }
+    /* ==== Obtain remaining transfer byte count ==== */
+    *remain = DMAC1.CRTB_n;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC1_Load_Set
+* Description  : Sets the transfer source address, transfer destination
+*              : address, and total transfer byte count respectively
+*              : specified by the argument src_addr, dst_addr, and count to
+*              : DMAC channel 1 as DMA transfer information.
+*              : Sets the register set selected by the CHCFG_n register
+*              : RSEL bit from the Next0 or Next1 register set.
+*              : This function should be called when DMA transfer of DMAC
+*              : channel 1 is aboted.
+* Arguments    : uint32_t src_addr : Transfer source address
+*              : uint32_t dst_addr : Transfer destination address
+*              : uint32_t count    : Total transfer byte count
+* Return Value : none
+*******************************************************************************/
+void usb0_function_DMAC1_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count)
+{
+    uint8_t reg_set;
+
+    /* Obtain register set in use */
+    reg_set = RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
+                                DMAC1_CHSTAT_n_SR_SHIFT,
+                                DMAC1_CHSTAT_n_SR);
+
+    /* ==== Load ==== */
+    if (0 == reg_set)
+    {
+        /* ---- Next0 Register Set ---- */
+        DMAC1.N0SA_n = src_addr;    /* Start address of transfer source      */
+        DMAC1.N0DA_n = dst_addr;    /* Start address of transfer destination */
+        DMAC1.N0TB_n = count;       /* Total transfer byte count             */
+    }
+    else
+    {
+        /* ---- Next1 Register Set ---- */
+        DMAC1.N1SA_n = src_addr;    /* Start address of transfer source      */
+        DMAC1.N1DA_n = dst_addr;    /* Start address of transfer destination */
+        DMAC1.N1TB_n = count;       /* Total transfer byte count             */
+     }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC2_PeriReqInit
+* Description  : Sets the register mode for DMA mode and the on-chip peripheral
+*              : module request for transfer request for DMAC channel 2.
+*              : Executes DMAC initial setting using the DMA information
+*              : specified by the argument *trans_info and the enabled/disabled
+*              : continuous transfer specified by the argument continuation.
+*              : Registers DMAC channel 2 interrupt handler function and sets
+*              : the interrupt priority level. Then enables transfer completion
+*              : interrupt.
+* Arguments    : dmac_transinfo_t * trans_info : Setting information to DMAC
+*              :                               : register
+*              : uint32_t dmamode      : DMA mode (only for DMAC_MODE_REGISTER)
+*              : uint32_t continuation : Set continuous transfer to be valid
+*              :                       : after DMA transfer has been completed
+*              :         DMAC_SAMPLE_CONTINUATION : Execute continuous transfer
+*              :         DMAC_SAMPLE_SINGLE       : Do not execute continuous
+*              :                                  : transfer
+*              : uint32_t request_factor : Factor for on-chip peripheral module
+*              :                         : request
+*              :         DMAC_REQ_OSTM0TINT : OSTM_0 compare match
+*              :         DMAC_REQ_OSTM1TINT : OSTM_1 compare match
+*              :         DMAC_REQ_TGI0A     : MTU2_0 input capture/compare match
+*              :                 :
+*              : uint32_t req_direction : Setting value of CHCFG_n register
+*              :                        : REQD bit
+*******************************************************************************/
+void usb0_function_DMAC2_PeriReqInit (const dmac_transinfo_t * trans_info,
+                                      uint32_t dmamode, uint32_t continuation,
+                                      uint32_t request_factor, uint32_t req_direction)
+{
+    /* ==== Register mode ==== */
+    if (DMAC_MODE_REGISTER == dmamode)
+    {
+        /* ==== Next0 register set ==== */
+        DMAC2.N0SA_n = trans_info->src_addr;        /* Start address of transfer source      */
+        DMAC2.N0DA_n = trans_info->dst_addr;        /* Start address of transfer destination */
+        DMAC2.N0TB_n = trans_info->count;           /* Total transfer byte count             */
+
+        /* DAD : Transfer destination address counting direction */
+        /* SAD : Transfer source address counting direction      */
+        /* DDS : Transfer destination transfer size              */
+        /* SDS : Transfer source transfer size                   */
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            trans_info->daddr_dir,
+                            DMAC2_CHCFG_n_DAD_SHIFT,
+                            DMAC2_CHCFG_n_DAD);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            trans_info->saddr_dir,
+                            DMAC2_CHCFG_n_SAD_SHIFT,
+                            DMAC2_CHCFG_n_SAD);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            trans_info->dst_size,
+                            DMAC2_CHCFG_n_DDS_SHIFT,
+                            DMAC2_CHCFG_n_DDS);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            trans_info->src_size,
+                            DMAC2_CHCFG_n_SDS_SHIFT,
+                            DMAC2_CHCFG_n_SDS);
+
+        /* DMS  : Register mode                            */
+        /* RSEL : Select Next0 register set                */
+        /* SBE  : No discharge of buffer data when aborted */
+        /* DEM  : No DMA interrupt mask                    */
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            0,
+                            DMAC2_CHCFG_n_DMS_SHIFT,
+                            DMAC2_CHCFG_n_DMS);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            0,
+                            DMAC2_CHCFG_n_RSEL_SHIFT,
+                            DMAC2_CHCFG_n_RSEL);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            0,
+                            DMAC2_CHCFG_n_SBE_SHIFT,
+                            DMAC2_CHCFG_n_SBE);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            0,
+                            DMAC2_CHCFG_n_DEM_SHIFT,
+                            DMAC2_CHCFG_n_DEM);
+
+        /* ---- Continuous transfer ---- */
+        if (DMAC_SAMPLE_CONTINUATION == continuation)
+        {
+            /* REN : Execute continuous transfer                         */
+            /* RSW : Change register set when DMA transfer is completed. */
+            RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                                1,
+                                DMAC2_CHCFG_n_REN_SHIFT,
+                                DMAC2_CHCFG_n_REN);
+            RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                                1,
+                                DMAC2_CHCFG_n_RSW_SHIFT,
+                                DMAC2_CHCFG_n_RSW);
+        }
+        /* ---- Single transfer ---- */
+        else
+        {
+            /* REN : Do not execute continuous transfer                         */
+            /* RSW : Do not change register set when DMA transfer is completed. */
+            RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                                0,
+                                DMAC2_CHCFG_n_REN_SHIFT,
+                                DMAC2_CHCFG_n_REN);
+            RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                                0,
+                                DMAC2_CHCFG_n_RSW_SHIFT,
+                                DMAC2_CHCFG_n_RSW);
+        }
+
+        /* TM  : Single transfer                          */
+        /* SEL : Channel setting                          */
+        /* HIEN, LOEN : On-chip peripheral module request */
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            0,
+                            DMAC2_CHCFG_n_TM_SHIFT,
+                            DMAC2_CHCFG_n_TM);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            2,
+                            DMAC2_CHCFG_n_SEL_SHIFT,
+                            DMAC2_CHCFG_n_SEL);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            1,
+                            DMAC2_CHCFG_n_HIEN_SHIFT,
+                            DMAC2_CHCFG_n_HIEN);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            0,
+                            DMAC2_CHCFG_n_LOEN_SHIFT,
+                            DMAC2_CHCFG_n_LOEN);
+
+        /* ---- Set factor by specified on-chip peripheral module request ---- */
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM],
+                            DMAC2_CHCFG_n_AM_SHIFT,
+                            DMAC2_CHCFG_n_AM);
+        RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL],
+                            DMAC2_CHCFG_n_LVL_SHIFT,
+                            DMAC2_CHCFG_n_LVL);
+        if (usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE)
+        {
+            RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                                usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD],
+                                DMAC2_CHCFG_n_REQD_SHIFT,
+                                DMAC2_CHCFG_n_REQD);
+        }
+        else
+        {
+            RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
+                                req_direction,
+                                DMAC2_CHCFG_n_REQD_SHIFT,
+                                DMAC2_CHCFG_n_REQD);
+        }
+        RZA_IO_RegWrite_32(&DMAC23.DMARS,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID],
+                            DMAC23_DMARS_CH2_RID_SHIFT,
+                            DMAC23_DMARS_CH2_RID);
+        RZA_IO_RegWrite_32(&DMAC23.DMARS,
+                            usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID],
+                            DMAC23_DMARS_CH2_MID_SHIFT,
+                            DMAC23_DMARS_CH2_MID);
+
+        /* PR : Round robin mode */
+        RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7,
+                            1,
+                            DMAC07_DCTRL_0_7_PR_SHIFT,
+                            DMAC07_DCTRL_0_7_PR);
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC2_Open
+* Description  : Enables DMAC channel 2 transfer.
+* Arguments    : uint32_t req : DMAC request mode
+* Return Value :  0 : Succeeded in enabling DMA transfer
+*              : -1 : Failed to enable DMA transfer (due to DMA operation)
+*******************************************************************************/
+int32_t usb0_function_DMAC2_Open (uint32_t req)
+{
+    int32_t ret;
+    volatile uint8_t dummy;
+
+    /* Transferable? */
+    if ((0 == RZA_IO_RegRead_32(&DMAC.CHSTAT_2,
+                                DMAC2_CHSTAT_n_EN_SHIFT,
+                                DMAC2_CHSTAT_n_EN)) &&
+        (0 == RZA_IO_RegRead_32(&DMAC.CHSTAT_2,
+                                DMAC2_CHSTAT_n_TACT_SHIFT,
+                                DMAC2_CHSTAT_n_TACT)))
+    {
+        /* Clear Channel Status Register */
+        RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
+                            1,
+                            DMAC2_CHCTRL_n_SWRST_SHIFT,
+                            DMAC2_CHCTRL_n_SWRST);
+        dummy = RZA_IO_RegRead_32(&DMAC2.CHCTRL_n,
+                                DMAC2_CHCTRL_n_SWRST_SHIFT,
+                                DMAC2_CHCTRL_n_SWRST);
+        /* Enable DMA transfer */
+        RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
+                            1,
+                            DMAC2_CHCTRL_n_SETEN_SHIFT,
+                            DMAC2_CHCTRL_n_SETEN);
+
+        /* ---- Request by software ---- */
+        if (DMAC_REQ_MODE_SOFT == req)
+        {
+            /* DMA transfer Request by software */
+            RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
+                                1,
+                                DMAC2_CHCTRL_n_STG_SHIFT,
+                                DMAC2_CHCTRL_n_STG);
+        }
+
+        ret = 0;
+    }
+    else
+    {
+        ret = -1;
+    }
+
+    return ret;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC2_Close
+* Description  : Aborts DMAC channel 2 transfer. Returns the remaining transfer
+*              : byte count at the time of DMA transfer abort to the argument
+*              : *remain.
+* Arguments    : uint32_t * remain : Remaining transfer byte count when
+*              :                   : DMA transfer is aborted
+* Return Value : none
+*******************************************************************************/
+void usb0_function_DMAC2_Close (uint32_t * remain)
+{
+
+    /* ==== Abort transfer ==== */
+    RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
+                        1,
+                        DMAC2_CHCTRL_n_CLREN_SHIFT,
+                        DMAC2_CHCTRL_n_CLREN);
+
+    while (1 == RZA_IO_RegRead_32(&DMAC2.CHSTAT_n,
+                                DMAC2_CHSTAT_n_TACT_SHIFT,
+                                DMAC2_CHSTAT_n_TACT))
+    {
+        /* Loop until transfer is aborted */
+    }
+
+    while (1 == RZA_IO_RegRead_32(&DMAC2.CHSTAT_n,
+                                DMAC2_CHSTAT_n_EN_SHIFT,
+                                DMAC2_CHSTAT_n_EN))
+    {
+        /* Loop until 0 is set in EN before checking the remaining transfer byte count */
+    }
+    /* ==== Obtain remaining transfer byte count ==== */
+    *remain = DMAC2.CRTB_n;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_DMAC2_Load_Set
+* Description  : Sets the transfer source address, transfer destination
+*              : address, and total transfer byte count respectively
+*              : specified by the argument src_addr, dst_addr, and count to
+*              : DMAC channel 2 as DMA transfer information.
+*              : Sets the register set selected by the CHCFG_n register
+*              : RSEL bit from the Next0 or Next1 register set.
+*              : This function should be called when DMA transfer of DMAC
+*              : channel 2 is aboted.
+* Arguments    : uint32_t src_addr : Transfer source address
+*              : uint32_t dst_addr : Transfer destination address
+*              : uint32_t count    : Total transfer byte count
+* Return Value : none
+*******************************************************************************/
+void usb0_function_DMAC2_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count)
+{
+    uint8_t reg_set;
+
+    /* Obtain register set in use */
+    reg_set = RZA_IO_RegRead_32(&DMAC2.CHSTAT_n,
+                                DMAC2_CHSTAT_n_SR_SHIFT,
+                                DMAC2_CHSTAT_n_SR);
+
+    /* ==== Load ==== */
+    if (0 == reg_set)
+    {
+        /* ---- Next0 Register Set ---- */
+        DMAC2.N0SA_n = src_addr;     /* Start address of transfer source      */
+        DMAC2.N0DA_n = dst_addr;     /* Start address of transfer destination */
+        DMAC2.N0TB_n = count;        /* Total transfer byte count             */
+    }
+    else
+    {
+        /* ---- Next1 Register Set ---- */
+        DMAC2.N1SA_n = src_addr;     /* Start address of transfer source      */
+        DMAC2.N1DA_n = dst_addr;     /* Start address of transfer destination */
+        DMAC2.N1TB_n = count;        /* Total transfer byte count             */
+     }
+}
+
+/* End of File */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/usb0_function_userdef.c	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,762 @@
+/*******************************************************************************
+* DISCLAIMER
+* This software is supplied by Renesas Electronics Corporation and is only
+* intended for use with Renesas products. No other uses are authorized. This
+* software is owned by Renesas Electronics Corporation and is protected under
+* all applicable laws, including copyright laws.
+* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
+* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
+* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
+* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
+* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
+* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
+* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
+* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+* Renesas reserves the right, without notice, to make changes to this software
+* and to discontinue the availability of this software. By using this software,
+* you agree to the additional terms and conditions found by accessing the
+* following link:
+* http://www.renesas.com/disclaimer
+* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
+*******************************************************************************/
+/*******************************************************************************
+* File Name    : usb0_function_userdef.c
+* $Rev: 1116 $
+* $Date:: 2014-07-09 16:29:19 +0900#$
+* Device(s)    : RZ/A1H
+* Tool-Chain   :
+* OS           : None
+* H/W Platform :
+* Description  : RZ/A1H R7S72100 USB Sample Program
+* Operation    :
+* Limitations  :
+*******************************************************************************/
+
+
+/*******************************************************************************
+Includes   <System Includes> , "Project Includes"
+*******************************************************************************/
+#include <stdio.h>
+#include "r_typedefs.h"
+#include "iodefine.h"
+#include "devdrv_usb_function_api.h"
+#include "usb0_function_dmacdrv.h"  /* common DMAC driver for USB */
+
+
+/*******************************************************************************
+Typedef definitions
+*******************************************************************************/
+
+
+/*******************************************************************************
+Macro definitions
+*******************************************************************************/
+#define DUMMY_ACCESS (*(volatile unsigned long *)(OSTM0CNT))
+
+/* #define CACHE_WRITEBACK */
+
+
+/*******************************************************************************
+Imported global variables and functions (from other files)
+*******************************************************************************/
+extern int32_t io_cwb(unsigned long start, unsigned long end);
+
+
+/*******************************************************************************
+Exported global variables and functions (to be accessed by other files)
+*******************************************************************************/
+static void usb0_function_enable_dmac0(uint32_t src, uint32_t dst, uint32_t count,
+                                       uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc);
+static void usb0_function_enable_dmac1(uint32_t src, uint32_t dst, uint32_t count,
+                                       uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc);
+static void Userdef_USB_usb0_function_delay_10us_2(void);
+
+
+/*******************************************************************************
+Private global variables and functions
+*******************************************************************************/
+
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_d0fifo_dmaintid
+* Description  : get D0FIFO DMA Interrupt ID
+* Arguments    : none
+* Return Value : D0FIFO DMA Interrupt ID
+*******************************************************************************/
+IRQn_Type Userdef_USB_usb0_function_d0fifo_dmaintid (void)
+{
+#if 0
+    return DMAINT1_IRQn;
+#else
+    return 0xFFFF;
+#endif
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_d1fifo_dmaintid
+* Description  : get D1FIFO DMA Interrupt ID
+* Arguments    : none
+* Return Value : D1FIFO DMA Interrupt ID
+*******************************************************************************/
+IRQn_Type Userdef_USB_usb0_function_d1fifo_dmaintid (void)
+{
+#if 0
+    return DMAINT1_IRQn;
+#else
+    return 0xFFFF;
+#endif
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_attach
+* Description  : Wait for the software of 1ms.
+*              : Alter this function according to the user's system.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_attach (void)
+{
+    printf("\n");
+    printf("channel 0 attach device\n");
+    printf("\n");
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_detach
+* Description  : Wait for the software of 1ms.
+*              : Alter this function according to the user's system.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_detach (void)
+{
+    printf("\n");
+    printf("channel 0 detach device\n");
+    printf("\n");
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_delay_1ms
+* Description  : Wait for the software of 1ms.
+*              : Alter this function according to the user's system.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_delay_1ms (void)
+{
+    volatile int i;
+    volatile unsigned long tmp;
+
+    /*
+     * Wait 1ms (Please change for your MCU).
+     */
+    for (i = 0; i < 1440; ++i)
+    {
+        tmp = DUMMY_ACCESS;
+    }
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_delay_xms
+* Description  : Wait for the software in the period of time specified by the
+*              : argument.
+*              : Alter this function according to the user's system.
+* Arguments    : uint32_t msec ; Wait Time (msec)
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_delay_xms (uint32_t msec)
+{
+    volatile unsigned short i;
+
+    for (i = 0; i < msec; ++i)
+    {
+        Userdef_USB_usb0_function_delay_1ms();
+    }
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_delay_10us
+* Description  : Waits for software for the period specified by the argument.
+*              : Alter this function according to the user's system.
+* Arguments    : uint32_t usec ; Wait Time(x 10usec)
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_delay_10us (uint32_t usec)
+{
+    volatile int i;
+
+    /* Wait 10us (Please change for your MCU) */
+    for (i = 0; i < usec; ++i)
+    {
+        Userdef_USB_usb0_function_delay_10us_2();
+    }
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_delay_10us_2
+* Description  : Waits for software for the period specified by the argument.
+*              : Alter this function according to the user's system.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+static void Userdef_USB_usb0_function_delay_10us_2 (void)
+{
+    volatile int i;
+    volatile unsigned long tmp;
+
+    /* Wait 1us (Please change for your MCU) */
+    for (i = 0; i < 14; ++i)
+    {
+        tmp = DUMMY_ACCESS;
+    }
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_delay_500ns
+* Description  : Wait for software for 500ns.
+*              : Alter this function according to the user's system.
+* Arguments    : none
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_delay_500ns (void)
+{
+    volatile int i;
+    volatile unsigned long tmp;
+
+    /* Wait 500ns (Please change for your MCU) */
+    /* Wait 500ns I clock 266MHz */
+    tmp = DUMMY_ACCESS;
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_start_dma
+* Description  : Enables DMA transfer on the information specified by the argument.
+*              : Set DMAC register by this function to enable DMA transfer.
+*              : After executing this function, USB module is set to start DMA
+*              : transfer. DMA transfer should not wait for DMA transfer complete.
+* Arguments    : USB_FUNCTION_DMA_t *dma   : DMA parameter
+*              :  typedef struct{
+*              :      uint32_t fifo;    FIFO for using
+*              :      uint32_t buffer;  Start address of transfer source/destination
+*              :      uint32_t bytes;   Transfer size(Byte)
+*              :      uint32_t dir;     Transfer direction(0:Buffer->FIFO, 1:FIFO->Buffer)
+*              :      uint32_t size;    DMA transfer size
+*              :   } USB_FUNCTION_DMA_t;
+*              : uint16_t dfacc ; 0 : cycle steal mode
+*              :                  1 : 16byte continuous mode
+*              :                  2 : 32byte continuous mode
+* Return Value : none
+*******************************************************************************/
+void Userdef_USB_usb0_function_start_dma (USB_FUNCTION_DMA_t * dma, uint16_t dfacc)
+{
+    uint32_t trncount;
+    uint32_t src;
+    uint32_t dst;
+    uint32_t size;
+    uint32_t dir;
+#ifdef CACHE_WRITEBACK
+    uint32_t ptr;
+#endif
+
+    trncount = dma->bytes;
+    dir      = dma->dir;
+
+    if (dir == USB_FUNCTION_FIFO2BUF)
+    {
+        /* DxFIFO determination */
+        dst = dma->buffer;
+#ifndef __USB_FUNCTION_DF_ACC_ENABLE__
+        if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+        {
+            src = (uint32_t)(&USB200.D0FIFO.UINT32);
+        }
+        else
+        {
+            src = (uint32_t)(&USB200.D1FIFO.UINT32);
+        }
+        size = dma->size;
+
+        if (size == 0)
+        {
+            src += 3;       /* byte access  */
+        }
+        else if (size == 1)
+        {
+            src += 2;       /* short access */
+        }
+        else
+        {
+            /* Do Nothing */
+        }
+#else
+        size = dma->size;
+
+        if (size == 2)
+        {
+            /* 32bit access */
+            if (dfacc == 2)
+            {
+                /* 32byte access */
+                if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+                {
+                    src = (uint32_t)(&USB200.D0FIFOB0);
+                }
+                else
+                {
+                    src = (uint32_t)(&USB200.D1FIFOB0);
+                }
+            }
+            else if (dfacc == 1)
+            {
+                /* 16byte access */
+                if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+                {
+                    src = (uint32_t)(&USB200.D0FIFOB0);
+                }
+                else
+                {
+                    src = (uint32_t)(&USB200.D1FIFOB0);
+                }
+            }
+            else
+            {
+                /* normal access */
+                if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+                {
+                    src = (uint32_t)(&USB200.D0FIFO.UINT32);
+                }
+                else
+                {
+                    src = (uint32_t)(&USB200.D1FIFO.UINT32);
+                }
+            }
+        }
+        else if (size == 1)
+        {
+            /* 16bit access */
+            dfacc = 0;      /* force normal access */
+
+            if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+            {
+                src = (uint32_t)(&USB200.D0FIFO.UINT32);
+            }
+            else
+            {
+                src = (uint32_t)(&USB200.D1FIFO.UINT32);
+            }
+            src += 2;       /* short access */
+        }
+        else
+        {
+            /* 8bit access */
+            dfacc = 0;      /* force normal access */
+
+            if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+            {
+                src = (uint32_t)(&USB200.D0FIFO.UINT32);
+            }
+            else
+            {
+                src = (uint32_t)(&USB200.D1FIFO.UINT32);
+            }
+            src += 3;       /* byte access */
+        }
+#endif
+    }
+    else
+    {
+        /* DxFIFO determination */
+        src = dma->buffer;
+#ifndef __USB_FUNCTION_DF_ACC_ENABLE__
+        if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+        {
+            dst = (uint32_t)(&USB200.D0FIFO.UINT32);
+        }
+        else
+        {
+            dst = (uint32_t)(&USB200.D1FIFO.UINT32);
+        }
+        size = dma->size;
+
+        if (size == 0)
+        {
+            dst += 3;       /* byte access  */
+        }
+        else if (size == 1)
+        {
+            dst += 2;       /* short access */
+        }
+        else
+        {
+            /* Do Nothing */
+        }
+#else
+        size = dma->size;
+
+        if (size == 2)
+        {
+            /* 32bit access */
+            if (dfacc == 2)
+            {
+                /* 32byte access */
+                if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+                {
+                    dst = (uint32_t)(&USB200.D0FIFOB0);
+                }
+                else
+                {
+                    dst = (uint32_t)(&USB200.D1FIFOB0);
+                }
+            }
+            else if (dfacc == 1)
+            {
+                /* 16byte access */
+                if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+                {
+                    dst = (uint32_t)(&USB200.D0FIFOB0);
+                }
+                else
+                {
+                    dst = (uint32_t)(&USB200.D1FIFOB0);
+                }
+            }
+            else
+            {
+                /* normal access */
+                if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+                {
+                    dst = (uint32_t)(&USB200.D0FIFO.UINT32);
+                }
+                else
+                {
+                    dst = (uint32_t)(&USB200.D1FIFO.UINT32);
+                }
+            }
+        }
+        else if (size == 1)
+        {
+            /* 16bit access */
+            dfacc = 0;      /* force normal access */
+            if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+            {
+                dst = (uint32_t)(&USB200.D0FIFO.UINT32);
+            }
+            else
+            {
+                dst = (uint32_t)(&USB200.D1FIFO.UINT32);
+            }
+            dst += 2;       /* short access */
+        }
+        else
+        {
+            /* 8bit access */
+            dfacc = 0;      /* force normal access */
+
+            if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+            {
+                dst = (uint32_t)(&USB200.D0FIFO.UINT32);
+            }
+            else
+            {
+                dst = (uint32_t)(&USB200.D1FIFO.UINT32);
+            }
+            dst += 3;       /* byte access  */
+        }
+#endif
+    }
+
+#ifdef CACHE_WRITEBACK
+    ptr = (uint32_t)dma->buffer;
+
+    if ((ptr & 0x20000000ul) == 0)
+    {
+        io_cwb((uint32_t)ptr, (uint32_t)(ptr) + trncount);
+    }
+#endif
+
+    if (dma->fifo == USB_FUNCTION_D0FIFO_DMA)
+    {
+        usb0_function_enable_dmac0(src, dst, trncount, size, dir, dma->fifo, dfacc);
+    }
+    else
+    {
+        usb0_function_enable_dmac1(src, dst, trncount, size, dir, dma->fifo, dfacc);
+    }
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_enable_dmac0
+* Description  : Enables DMA transfer on the information specified by the argument.
+* Arguments    : uint32_t src   : src address
+*              : uint32_t dst   : dst address
+*              : uint32_t count : transfer byte
+*              : uint32_t size  : transfer size
+*              : uint32_t dir   : direction
+*              : uint32_t fifo  : FIFO(D0FIFO or D1FIFO)
+*              : uint16_t dfacc : 0 : normal access
+*              :                : 1 : 16byte access
+*              :                : 2 : 32byte access
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_enable_dmac0 (uint32_t src, uint32_t dst, uint32_t count,
+                                        uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc)
+{
+    dmac_transinfo_t trans_info;
+    uint32_t         request_factor = 0;
+    int32_t          ret;
+
+    /* ==== Variable setting for DMAC initialization ==== */
+    trans_info.src_addr = (uint32_t)src;                /* Start address of transfer source      */
+    trans_info.dst_addr = (uint32_t)dst;                /* Start address of transfer destination */
+    trans_info.count    = (uint32_t)count;              /* Total byte count to be transferred    */
+#ifndef __USB_FUNCTION_DF_ACC_ENABLE__
+    if (size == 0)
+    {
+        trans_info.src_size = DMAC_TRANS_SIZE_8;        /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_8;        /* Transfer destination transfer size */
+    }
+    else if (size == 1)
+    {
+        trans_info.src_size = DMAC_TRANS_SIZE_16;       /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_16;       /* Transfer destination transfer size */
+    }
+    else if (size == 2)
+    {
+        trans_info.src_size = DMAC_TRANS_SIZE_32;       /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_32;       /* Transfer destination transfer size */
+    }
+    else
+    {
+        printf("size error!!\n");
+    }
+#else
+    if (dfacc == 2)
+    {
+        /* 32byte access */
+        trans_info.src_size = DMAC_TRANS_SIZE_256;      /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_256;      /* Transfer destination transfer size */
+    }
+    else if (dfacc == 1)
+    {
+        /* 16byte access */
+        trans_info.src_size = DMAC_TRANS_SIZE_128;      /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_128;      /* Transfer destination transfer size */
+    }
+    else
+    {
+        /* normal access */
+        if (size == 0)
+        {
+            trans_info.src_size = DMAC_TRANS_SIZE_8;    /* Transfer source transfer size      */
+            trans_info.dst_size = DMAC_TRANS_SIZE_8;    /* Transfer destination transfer size */
+        }
+        else if (size == 1)
+        {
+            trans_info.src_size = DMAC_TRANS_SIZE_16;   /* Transfer source transfer size      */
+            trans_info.dst_size = DMAC_TRANS_SIZE_16;   /* Transfer destination transfer size */
+        }
+        else if (size == 2)
+        {
+            trans_info.src_size = DMAC_TRANS_SIZE_32;   /* Transfer source transfer size      */
+            trans_info.dst_size = DMAC_TRANS_SIZE_32;   /* Transfer destination transfer size */
+        }
+        else
+        {
+            printf("size error!!\n");
+        }
+    }
+#endif
+
+    if (dir == USB_FUNCTION_FIFO2BUF)
+    {
+        request_factor =DMAC_REQ_USB0_DMA0_RX;          /* USB_0 channel 0 receive FIFO full               */
+        trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC;   /* Count direction of transfer source address      */
+        trans_info.daddr_dir = DMAC_TRANS_ADR_INC;      /* Count direction of transfer destination address */
+    }
+    else if (dir == USB_FUNCTION_BUF2FIFO)
+    {
+        request_factor =DMAC_REQ_USB0_DMA0_TX;          /* USB_0 channel 0 receive FIFO empty              */
+        trans_info.saddr_dir = DMAC_TRANS_ADR_INC;      /* Count direction of transfer source address      */
+        trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC;   /* Count direction of transfer destination address */
+    }
+    else
+    {
+        /* Do Nothing */
+    }
+
+    /* ==== DMAC initialization ==== */
+    usb0_function_DMAC1_PeriReqInit((const dmac_transinfo_t *)&trans_info,
+                                    DMAC_MODE_REGISTER,
+                                    DMAC_SAMPLE_SINGLE,
+                                    request_factor,
+                                    0);     /* Don't care DMAC_REQ_REQD is setting in
+                                            usb0_function_DMAC1_PeriReqInit() */
+
+    /* ==== DMAC startup ==== */
+    ret = usb0_function_DMAC1_Open(DMAC_REQ_MODE_PERI);
+    if (ret != 0)
+    {
+        printf("DMAC1 Open error!!\n");
+    }
+
+    return;
+}
+
+/*******************************************************************************
+* Function Name: usb0_function_enable_dmac1
+* Description  : Enables DMA transfer on the information specified by the argument.
+* Arguments    : uint32_t src   : src address
+*              : uint32_t dst   : dst address
+*              : uint32_t count : transfer byte
+*              : uint32_t size  : transfer size
+*              : uint32_t dir   : direction
+*              : uint32_t fifo  : FIFO(D0FIFO or D1FIFO)
+*              : uint16_t dfacc : 0 : normal access
+*              :                : 1 : 16byte access
+*              :                : 2 : 32byte access
+* Return Value : none
+*******************************************************************************/
+static void usb0_function_enable_dmac1 (uint32_t src, uint32_t dst, uint32_t count,
+                                        uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc)
+{
+    dmac_transinfo_t trans_info;
+    uint32_t         request_factor = 0;
+    int32_t          ret;
+
+    /* ==== Variable setting for DMAC initialization ==== */
+    trans_info.src_addr = (uint32_t)src;                /* Start address of transfer source      */
+    trans_info.dst_addr = (uint32_t)dst;                /* Start address of transfer destination */
+    trans_info.count    = (uint32_t)count;              /* Total byte count to be transferred    */
+#ifndef __USB_FUNCTION_DF_ACC_ENABLE__
+    if (size == 0)
+    {
+        trans_info.src_size = DMAC_TRANS_SIZE_8;        /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_8;        /* Transfer destination transfer size */
+    }
+    else if (size == 1)
+    {
+        trans_info.src_size = DMAC_TRANS_SIZE_16;       /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_16;       /* Transfer destination transfer size */
+    }
+    else if (size == 2)
+    {
+        trans_info.src_size = DMAC_TRANS_SIZE_32;       /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_32;       /* Transfer destination transfer size */
+    }
+    else
+    {
+        printf("size error!!\n");
+    }
+#else
+    if (dfacc == 2)
+    {
+        /* 32byte access */
+        trans_info.src_size = DMAC_TRANS_SIZE_256;      /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_256;      /* Transfer destination transfer size */
+    }
+    else if (dfacc == 1)
+    {
+        /* 16byte access */
+        trans_info.src_size = DMAC_TRANS_SIZE_128;      /* Transfer source transfer size      */
+        trans_info.dst_size = DMAC_TRANS_SIZE_128;      /* Transfer destination transfer size */
+    }
+    else
+    {
+        /* normal access */
+        if (size == 0)
+        {
+            trans_info.src_size = DMAC_TRANS_SIZE_8;    /* Transfer source transfer size      */
+            trans_info.dst_size = DMAC_TRANS_SIZE_8;    /* Transfer destination transfer size */
+        }
+        else if (size == 1)
+        {
+            trans_info.src_size = DMAC_TRANS_SIZE_16;   /* Transfer source transfer size      */
+            trans_info.dst_size = DMAC_TRANS_SIZE_16;   /* Transfer destination transfer size */
+        }
+        else if (size == 2)
+        {
+            trans_info.src_size = DMAC_TRANS_SIZE_32;   /* Transfer source transfer size      */
+            trans_info.dst_size = DMAC_TRANS_SIZE_32;   /* Transfer destination transfer size */
+        }
+        else
+        {
+            printf("size error!!\n");
+        }
+    }
+#endif
+
+    if (dir == USB_FUNCTION_FIFO2BUF)
+    {
+        request_factor =DMAC_REQ_USB0_DMA1_RX;          /* USB_0 channel 0 receive FIFO full               */
+        trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC;   /* Count direction of transfer source address      */
+        trans_info.daddr_dir = DMAC_TRANS_ADR_INC;      /* Count direction of transfer destination address */
+    }
+    else if (dir == USB_FUNCTION_BUF2FIFO)
+    {
+        request_factor =DMAC_REQ_USB0_DMA1_TX;          /* USB_0 channel 0 receive FIFO empty              */
+        trans_info.saddr_dir = DMAC_TRANS_ADR_INC;      /* Count direction of transfer source address      */
+        trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC;   /* Count direction of transfer destination address */
+    }
+    else
+    {
+        /* Do Nothing */
+    }
+
+    /* ==== DMAC initialization ==== */
+    usb0_function_DMAC2_PeriReqInit((const dmac_transinfo_t *)&trans_info,
+                                    DMAC_MODE_REGISTER,
+                                    DMAC_SAMPLE_SINGLE,
+                                    request_factor,
+                                    0);     /* Don't care DMAC_REQ_REQD is setting in
+                                            usb0_function_DMAC1_PeriReqInit() */
+
+    /* ==== DMAC startup ==== */
+    ret = usb0_function_DMAC2_Open(DMAC_REQ_MODE_PERI);
+    if (ret != 0)
+    {
+        printf("DMAC2 Open error!!\n");
+    }
+
+    return;
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_stop_dma0
+* Description  : Disables DMA transfer.
+*              : This function should be executed to DMAC executed at the time
+*              : of specification of D0_FIF0_DMA in dma->fifo.
+* Arguments    : none
+* Return Value : uint32_t return Transfer Counter register(DMATCRn) value
+*              : regarding to the bus width.
+*******************************************************************************/
+uint32_t Userdef_USB_usb0_function_stop_dma0 (void)
+{
+    uint32_t remain;
+
+    /* ==== DMAC release ==== */
+    usb0_function_DMAC1_Close(&remain);
+
+    return remain;
+}
+
+/*******************************************************************************
+* Function Name: Userdef_USB_usb0_function_stop_dma1
+* Description  : Disables DMA transfer.
+*              : This function should be executed to DMAC executed at the time
+*              : of specification of D1_FIF0_DMA in dma->fifo.
+* Arguments    : none
+* Return Value : uint32_t return Transfer Counter register(DMATCRn) value
+*              : regarding to the bus width.
+*******************************************************************************/
+uint32_t Userdef_USB_usb0_function_stop_dma1 (void)
+{
+    uint32_t remain;
+
+    /* ==== DMAC release ==== */
+    usb0_function_DMAC2_Close(&remain);
+
+    return remain;
+}
+
+/* End of File */
--- a/USBDevice/USBEndpoints.h	Thu Oct 23 09:45:42 2014 +0100
+++ b/USBDevice/USBEndpoints.h	Thu Nov 06 11:01:12 2014 +0000
@@ -45,6 +45,8 @@
 #include "USBEndpoints_KL25Z.h"
 #elif defined (TARGET_STM32F4)
 #include "USBEndpoints_STM32F4.h"
+#elif defined (TARGET_RZ_A1H)
+#include "USBEndpoints_RZ_A1H.h"
 #else
 #error "Unknown target type"
 #endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/USBEndpoints_RZ_A1H.h	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,79 @@
+/* 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.
+*/
+
+#define NUMBER_OF_LOGICAL_ENDPOINTS (16)
+#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2)
+
+/* Define physical endpoint numbers */
+
+/*      Endpoint    No.     Type(s)   MaxSiz  DoubleBuf  pipe */
+/*      ----------------    --------- ------  ---------  ---- */
+#define EP0OUT      (0)  /* Control    256    No           0  */
+#define EP0IN       (1)  /* Control    256    No           0  */
+#define EP1OUT      (2)  /* Int         64    No           6  */
+#define EP1IN       (3)  /* Int         64    No           7  */
+#define EP2OUT      (4)  /* Bulk      2048    Yes          3  */
+#define EP2IN       (5)  /* Bulk      2048    Yes          4  */
+#define EP3OUT      (6)  /* Bulk/Iso  2048    Yes          1  */
+#define EP3IN       (7)  /* Bulk/Iso  2048    Yes          2  */
+/*following EP is not configured in sample program*/
+#define EP6IN       (8)  /* Bulk      2048    Yes          5  */
+#define EP8IN       (9)  /* Int        64     No           8  */
+#define EP9IN       (10) /* Bulk       512    Bulk         9  */
+#define EP10IN      (11) /* Int/Bulk  2048    Bulk        10  */
+#define EP11IN      (12) /* Bulk      2048    Yes         11  */
+#define EP12IN      (13) /* Bulk      2048    Yes         12  */
+#define EP13IN      (14) /* Bulk      2048    Yes         13  */
+#define EP14IN      (15) /* Bulk      2048    Yes         14  */
+#define EP15IN      (16) /* Bulk      2048    Yes         15  */
+
+/* Maximum Packet sizes */
+#define MAX_PACKET_SIZE_EP0   (64)      /*pipe0/pipe0: control      */
+#define MAX_PACKET_SIZE_EP1   (64)      /*pipe6/pipe7: interrupt    */
+#define MAX_PACKET_SIZE_EP2  (512)      /*pipe3/pipe4: bulk         */
+#define MAX_PACKET_SIZE_EP3  (512)      /*pipe1/pipe2: isochronous  */
+#define MAX_PACKET_SIZE_EP6   (64)      /*pipe5:    Note *1 */
+#define MAX_PACKET_SIZE_EP8   (64)      /*pipe7:    Note *1 */
+#define MAX_PACKET_SIZE_EP9  (512)      /*pipe8:    Note *1 */
+#define MAX_PACKET_SIZE_EP10 (512)      /*pipe9:    Note *1 */
+#define MAX_PACKET_SIZE_EP11 (512)      /*pipe10:   Note *1 */
+#define MAX_PACKET_SIZE_EP12 (512)      /*pipe11:   Note *1 */
+#define MAX_PACKET_SIZE_EP13 (512)      /*pipe12:   Note *1 */
+#define MAX_PACKET_SIZE_EP14 (512)      /*pipe13:   Note *1 */
+#define MAX_PACKET_SIZE_EP15 (512)      /*pipe14:   Note *1 */
+/* Note *1: This pipe is not configure in sample program */
+
+
+/* Generic endpoints - intended to be portable accross devices */
+/* and be suitable for simple USB devices. */
+
+/* Bulk endpoints */
+#define EPBULK_OUT  (EP2OUT)
+#define EPBULK_IN   (EP2IN)
+/* Interrupt endpoints */
+#define EPINT_OUT   (EP1OUT)
+#define EPINT_IN    (EP1IN)
+/* Isochronous endpoints */
+#define EPISO_OUT   (EP3OUT)
+#define EPISO_IN    (EP3IN)
+
+#define MAX_PACKET_SIZE_EPBULK  (MAX_PACKET_SIZE_EP2)
+#define MAX_PACKET_SIZE_EPINT   (MAX_PACKET_SIZE_EP1)
+#define MAX_PACKET_SIZE_EPISO   (MAX_PACKET_SIZE_EP3)
+
+/*EOF*/
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/USBHAL_RZ_A1H.cpp	Thu Nov 06 11:01:12 2014 +0000
@@ -0,0 +1,1226 @@
+/* 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)
+
+/*
+  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 "usb0_function.h"
+#include "iobitmasks/usb_iobitmask.h"
+#include "rza_io_regrw.h"
+#include "USBDevice_Types.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,
+        64,
+        DEVDRV_USBF_OFF | 0,
+    },
+    {
+        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,
+        64,
+        DEVDRV_USBF_OFF | 0,
+    },
+    {
+        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,
+        512,
+        DEVDRV_USBF_OFF | 0,
+    },
+    {
+        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,
+        512,
+        DEVDRV_USBF_OFF | 0,
+    },
+    {
+        EP3OUT, /*EP3: Host -> Func, ISO*/
+        1 | USB_FUNCTION_D0FIFO_USE,
+        USB_FUNCTION_ISO       |
+        USB_FUNCTION_BFREOFF   |
+        USB_FUNCTION_DBLBON    |
+        USB_FUNCTION_CNTMDON   |
+        USB_FUNCTION_SHTNAKON  |
+        USB_FUNCTION_DIR_P_OUT |
+        USB_FUNCTION_EP3,
+        ( ( (1024) / 64 - 1 ) << 10 ) | 0x10u,
+        192,
+        DEVDRV_USBF_OFF | 1,
+    },
+    {
+        EP3IN,  /*EP3: Host <- Func, ISO*/
+        2 | USB_FUNCTION_D1FIFO_USE,
+        USB_FUNCTION_ISO       |
+        USB_FUNCTION_BFREOFF   |
+        USB_FUNCTION_DBLBON    |
+        USB_FUNCTION_CNTMDON   |
+        USB_FUNCTION_SHTNAKOFF |
+        USB_FUNCTION_DIR_P_IN  |
+        USB_FUNCTION_EP3,
+        ( ( (1024) / 64 - 1 ) << 10 ) | 0x20u,
+        192,
+        DEVDRV_USBF_OFF | 1,
+    },
+    { /*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 *usb0_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 */
+
+/* This C++ functions changed to macro functions.
+   static uint32_t EP2PIPE(uint8_t endpoint);
+   static void usb0_function_save_request(void);
+   void usb0_function_BRDYInterrupt(uint16_t status, uint16_t intenb);
+   void usb0_function_NRDYInterrupt (uint16_t status, uint16_t intenb);
+   void usb0_function_BEMPInterrupt (uint16_t status, uint16_t intenb);
+*/
+
+/*************************************************************************/
+/* macros */
+
+/******************************************************************************
+ * Function Name: usb0_function_BRDYInterruptPIPE0
+ * Description  : Executes BRDY interrupt for pipe0.
+ * Arguments    : uint16_t status       ; BRDYSTS Register Value
+ *              : uint16_t intenb       ; BRDYENB Register Value
+ * Return Value : none
+ *****************************************************************************/
+#define usb0_function_BRDYInterruptPIPE0(status, intenb)                \
+    {                                                                   \
+        volatile uint16_t dumy_sts;                                     \
+        uint16_t read_status;                                           \
+                                                                        \
+        USB200.BRDYSTS =                                                \
+            (uint16_t)~g_usb0_function_bit_set[USB_FUNCTION_PIPE0];     \
+        RZA_IO_RegWrite_16(                                             \
+            &USB200.CFIFOSEL, USB_FUNCTION_PIPE0,                       \
+            USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE);          \
+                                                                        \
+        g_usb0_function_PipeDataSize[USB_FUNCTION_PIPE0] =              \
+            g_usb0_function_data_count[USB_FUNCTION_PIPE0];             \
+                                                                        \
+        read_status = usb0_function_read_buffer_c(USB_FUNCTION_PIPE0);  \
+                                                                        \
+        g_usb0_function_PipeDataSize[USB_FUNCTION_PIPE0] -=             \
+            g_usb0_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 */                                         \
+                usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);          \
+                                                                        \
+                /*callback*/                                            \
+                EP0out();                                               \
+                break;                                                  \
+                                                                        \
+            case USB_FUNCTION_READSHRT:     /* End of data read */      \
+                usb0_function_disable_brdy_int(USB_FUNCTION_PIPE0);     \
+                /* PID = BUF */                                         \
+                usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);          \
+                                                                        \
+                /*callback*/                                            \
+                EP0out();                                               \
+                break;                                                  \
+                                                                        \
+            case USB_FUNCTION_READOVER:     /* FIFO access error */     \
+                /* Buffer Clear */                                      \
+                USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;                 \
+                usb0_function_disable_brdy_int(USB_FUNCTION_PIPE0);     \
+                /* Req Error */                                         \
+                usb0_function_set_pid_stall(USB_FUNCTION_PIPE0);        \
+                                                                        \
+                /*callback*/                                            \
+                EP0out();                                               \
+                break;                                                  \
+                                                                        \
+            case DEVDRV_USBF_FIFOERROR:     /* FIFO access error */     \
+            default:                                                    \
+                usb0_function_disable_brdy_int(USB_FUNCTION_PIPE0);     \
+                /* Req Error */                                         \
+                usb0_function_set_pid_stall(USB_FUNCTION_PIPE0);        \
+                break;                                                  \
+        }                                                               \
+        /* Three dummy reads for clearing interrupt requests */         \
+        dumy_sts = USB200.BRDYSTS;                                      \
+    }
+
+
+
+/******************************************************************************
+ * Function Name: usb0_function_BRDYInterrupt
+ * Description  : Executes BRDY interrupt uxclude pipe0.
+ * Arguments    : uint16_t status       ; BRDYSTS Register Value
+ *              : uint16_t intenb       ; BRDYENB Register Value
+ * Return Value : none
+ *****************************************************************************/
+#define usb0_function_BRDYInterrupt(status, intenb)                     \
+    {                                                                   \
+        volatile uint16_t dumy_sts;                                     \
+                                                                        \
+        /************************************************************** \
+         * Function Name: usb0_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 usb0_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_usb0_function_bit_set[pipe];                    \
+                                                                        \
+            if ((status & pipebit) && (intenb & pipebit)) {             \
+                USB200.BRDYSTS = (uint16_t)~pipebit;                    \
+                USB200.BEMPSTS = (uint16_t)~pipebit;                    \
+                                                                        \
+                switch (g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) { \
+                    case USB_FUNCTION_D0FIFO_DMA:                       \
+                        if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY) { \
+                            /*now, DMA is not supported*/               \
+                            usb0_function_dma_interrupt_d0fifo(int_sense); \
+                        }                                               \
+                                                                        \
+                        if (RZA_IO_RegRead_16(                          \
+                                &g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) { \
+                            /*now, DMA is not supported*/               \
+                            usb0_function_read_dma(pipe);               \
+                            usb0_function_disable_brdy_int(pipe);       \
+                        } else {                                        \
+                            USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;    \
+                            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; \
+                        }                                               \
+                        break;                                          \
+                                                                        \
+                    case USB_FUNCTION_D1FIFO_DMA:                       \
+                        if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY) { \
+                            /*now, DMA is not supported*/               \
+                            usb0_function_dma_interrupt_d1fifo(int_sense); \
+                        }                                               \
+                                                                        \
+                        if (RZA_IO_RegRead_16(                          \
+                                &g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) { \
+                            /*now, DMA is not supported*/               \
+                            usb0_function_read_dma(pipe);               \
+                            usb0_function_disable_brdy_int(pipe);       \
+                        } else {                                        \
+                            USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;    \
+                            g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; \
+                        }                                               \
+                        break;                                          \
+                                                                        \
+                    default:                                            \
+                        ep = (g_usb0_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; \
+                        ep <<= 1;                                       \
+                        ep += (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0)? \
+                            (0): (1);                                   \
+                        EPx_read_status = DEVDRV_USBF_PIPE_WAIT;        \
+                        (instance->*(epCallback[ep - 2])) ();           \
+                        EPx_read_status = DEVDRV_USBF_PIPE_DONE;        \
+                }                                                       \
+            }                                                           \
+        }                                                               \
+        /* Three dummy reads for clearing interrupt requests */         \
+        dumy_sts = USB200.BRDYSTS;                                      \
+    }
+
+
+/******************************************************************************
+ * Function Name: usb0_function_NRDYInterruptPIPE0
+ * Description  : Executes NRDY interrupt for pipe0.
+ * Arguments    : uint16_t status       ; NRDYSTS Register Value
+ *              : uint16_t intenb       ; NRDYENB Register Value
+ * Return Value : none
+ *****************************************************************************/
+#define usb0_function_NRDYInterruptPIPE0(status, intenb)                \
+    {                                                                   \
+        volatile uint16_t dumy_sts;                                     \
+                                                                        \
+        USB200.NRDYSTS =                                                \
+            (uint16_t)~g_usb0_function_bit_set[USB_FUNCTION_PIPE0];     \
+                                                                        \
+        /* Three dummy reads for clearing interrupt requests */         \
+        dumy_sts = USB200.NRDYSTS;                                      \
+    }
+
+/******************************************************************************
+ * Function Name: usb0_function_NRDYInterrupt
+ * Description  : Executes NRDY interrupt exclude pipe0.
+ * Arguments    : uint16_t status       ; NRDYSTS Register Value
+ *              : uint16_t intenb       ; NRDYENB Register Value
+ * Return Value : none
+ *****************************************************************************/
+#define usb0_function_NRDYInterrupt(status, intenb)                     \
+    {                                                                   \
+        volatile uint16_t dumy_sts;                                     \
+                                                                        \
+        usb0_function_nrdy_int(status, intenb);                         \
+                                                                        \
+        /* Three dummy reads for clearing interrupt requests */         \
+        dumy_sts = USB200.NRDYSTS;                                      \
+    }
+
+
+/******************************************************************************
+ * Function Name: usb0_function_BEMPInterruptPIPE0
+ * Description  : Executes BEMP interrupt for pipe0.
+ * Arguments    : uint16_t status       ; BEMPSTS Register Value
+ *              : uint16_t intenb       ; BEMPENB Register Value
+ * Return Value : none
+ *****************************************************************************/
+#define usb0_function_BEMPInterruptPIPE0(status, intenb)                \
+    {                                                                   \
+        volatile uint16_t dumy_sts;                                     \
+                                                                        \
+        USB200.BEMPSTS =                                                \
+            (uint16_t)~g_usb0_function_bit_set[USB_FUNCTION_PIPE0];     \
+        RZA_IO_RegWrite_16(                                             \
+            &USB200.CFIFOSEL, USB_FUNCTION_PIPE0,                       \
+            USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE);          \
+                                                                        \
+        /*usb0_function_write_buffer_c(USB_FUNCTION_PIPE0);*/           \
+        EP0in();                                                        \
+                                                                        \
+        /* Three dummy reads for clearing interrupt requests */         \
+        dumy_sts = USB200.BEMPSTS;                                      \
+    }
+
+
+/******************************************************************************
+ * Function Name: usb0_function_BEMPInterrupt
+ * Description  : Executes BEMP interrupt exclude pipe0.
+ * Arguments    : uint16_t status       ; BEMPSTS Register Value
+ *              : uint16_t intenb       ; BEMPENB Register Value
+ * Return Value : none
+ *****************************************************************************/
+#define usb0_function_BEMPInterrupt(status, intenb)                     \
+    {                                                                   \
+        volatile uint16_t dumy_sts;                                     \
+                                                                        \
+        usb0_function_bemp_int(status, intenb);                         \
+                                                                        \
+        /* Three dummy reads for clearing interrupt requests */         \
+        dumy_sts = USB200.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)usb0_function_EpToPipe(endpoint))
+
+
+/******************************************************************************
+ * Function Name: usb0_function_save_request
+ * Description  : Retains the USB request information in variables.
+ * Arguments    : none
+ * Return Value : none
+ *****************************************************************************/
+#define  usb0_function_save_request()                       \
+    {                                                       \
+        uint16_t *bufO = &setup_buffer[0];                  \
+                                                            \
+        USB200.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVALID;  \
+        /*data[0] <= bmRequest, data[1] <= bmRequestType */ \
+        *bufO++ = USB200.USBREQ;                            \
+        /*data[2] data[3] <= wValue*/                       \
+        *bufO++ = USB200.USBVAL;                            \
+        /*data[4] data[5] <= wIndex*/                       \
+        *bufO++ = USB200.USBINDX;                           \
+        /*data[6] data[6] <= wIndex*/                       \
+        *bufO++ = USB200.USBLENG;                           \
+}
+
+
+/*************************************************************************/
+/*************************************************************************/
+/*************************************************************************/
+
+/*************************************************************************/
+/* constructor */
+USBHAL::USBHAL(void)
+{
+    /* ---- P4_1 : P4_1 (USB0_EN for GR-PEACH) ---- */
+    usb0_en = new DigitalOut(P4_1, 1);
+
+    /* some constants */
+    int_id          = USBI0_IRQn;
+    int_level       = ( 2 << 3 );
+    clock_mode      = USBFCLOCK_X1_48MHZ;
+    mode            = USB_FUNCTION_HIGH_SPEED;
+    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 */
+    usb0_function_clear_pipe_tbl();
+
+/******************************************************************************
+ * Function Name: usb0_api_function_init
+ * Description  : Initializes the USB module in the USB function mode.
+ *****************************************************************************/
+    /* The clock of USB0 modules is permitted */
+    CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71);
+    volatile uint8_t    dummy8;
+    dummy8 = CPG.STBCR7;
+
+    {
+/******************************************************************************
+ * Function Name: usb0_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_usb0_function_d0fifo_dmaintid();
+        if (d0fifo_dmaintid != 0xFFFF) {
+            InterruptHandlerRegister(d0fifo_dmaintid, usb0_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_usb0_function_d1fifo_dmaintid();
+        if (d1fifo_dmaintid != 0xFFFF) {
+            InterruptHandlerRegister(d1fifo_dmaintid, usb0_function_dma_interrupt_d1fifo);
+            GIC_SetPriority(d1fifo_dmaintid, int_level);
+            GIC_EnableIRQ(d1fifo_dmaintid);
+        }
+#endif
+/*****************************************************************************/
+    }
+
+    /* reset USB module with setting tranciever and HSE=1 */
+    usb0_function_reset_module(clock_mode);
+
+    /* clear variables */
+    usb0_function_init_status();
+
+    /* select USB Function and Interrupt Enable */
+    /* Detect USB Device to attach or detach    */
+    usb0_function_InitModule(mode);
+
+    {
+        uint16_t buf;
+        buf  = USB200.INTENB0;
+        buf |= USB_INTENB0_SOFE;
+        USB200.INTENB0 = buf;
+    }
+}
+
+/*************************************************************************/
+USBHAL::~USBHAL(void)
+{
+    /* Disables interrupt for usb */
+    GIC_DisableIRQ( int_id );
+    /* Unregisters interrupt function and priority */
+    InterruptHandlerRegister( int_id, (uint32_t)NULL );
+
+    usb0_en  = NULL;
+    instance = NULL;
+}
+
+/*************************************************************************/
+void USBHAL::connect(void)
+{
+    /* Activates USB0_EN */
+    (*usb0_en) = 0;
+}
+
+
+/*************************************************************************/
+void USBHAL::disconnect(void)
+{
+    /* Deactivates USB0_EN */
+    (*usb0_en) = 1;
+}
+
+
+/*************************************************************************/
+void USBHAL::configureDevice(void)
+{
+    /*The pipes set up in USBHAL::realiseEndpoint*/
+    /*usb0_function_clear_alt();*/      /* Alternate setting clear */
+    /*usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);*/
+}
+
+
+/*************************************************************************/
+void USBHAL::unconfigureDevice(void)
+{
+    /* The Interface would be managed by USBDevice */
+    /*usb0_function_clear_alt();*/      /* Alternate setting clear */
+    /*usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);*/
+}
+
+
+/*************************************************************************/
+void USBHAL::setAddress(uint8_t address)
+{
+    if (address <= 127) {
+        usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);      /* OK */
+    } else {
+        usb0_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_usb0_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  = USB200.BRDYENB;
+    buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
+    USB200.BRDYENB = buf;
+    buf  = USB200.NRDYENB;
+    buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
+    USB200.NRDYENB = buf;
+    buf  = USB200.BEMPENB;
+    buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
+    USB200.BEMPENB = buf;
+
+    usb0_function_set_pid_nak(pipe);
+
+    /* CurrentPIPE Clear */
+    if (RZA_IO_RegRead_16(&USB200.CFIFOSEL, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE) == pipe) {
+        RZA_IO_RegWrite_16(&USB200.CFIFOSEL, 0, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE);
+    }
+
+    if (RZA_IO_RegRead_16(&USB200.D0FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) {
+        RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE);
+    }
+
+    if (RZA_IO_RegRead_16(&USB200.D1FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) {
+        RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE);
+    }
+
+    /* PIPE Configuration */
+    USB200.PIPESEL  = pipe;
+    USB200.PIPECFG  = cfg->pipecfg;
+    USB200.PIPEBUF  = cfg->pipebuf;
+    USB200.PIPEMAXP = cfg->pipemaxp;
+    USB200.PIPEPERI = cfg->pipeperi;
+
+    g_usb0_function_pipecfg[pipe]  = cfg->pipecfg;
+    g_usb0_function_pipebuf[pipe]  = cfg->pipebuf;
+    g_usb0_function_pipemaxp[pipe] = cfg->pipemaxp;
+    g_usb0_function_pipeperi[pipe] = cfg->pipeperi;
+
+    /* Buffer Clear */
+    usb0_function_set_sqclr(pipe);
+    usb0_function_aclrm(pipe);
+
+    /* init Global */
+    g_usb0_function_pipe_status[pipe]  = DEVDRV_USBF_PIPE_IDLE;
+    g_usb0_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;
+    usb0_api_function_CtrlWriteStart(size, buffer);
+}
+
+
+/*************************************************************************/
+uint32_t USBHAL::EP0getReadResult(uint8_t *buffer)
+{
+    memcpy(buffer, (uint8_t*)(&setup_buffer[4]), g_usb0_function_PipeDataSize[USB_FUNCTION_PIPE0]);
+
+    return g_usb0_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 = usb0_api_function_CtrlReadStart(size, buffer);
+    } else {
+        /* waits the last transmission */
+        /*other blocks*/
+        g_usb0_function_data_count[ USB_FUNCTION_PIPE0 ]    = size;
+        g_usb0_function_data_pointer [ USB_FUNCTION_PIPE0 ] = buffer;
+        EP0_read_status = usb0_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 = usb0_api_function_check_pipe_status(pipe, &pipe_size);
+    pipe_size = (max_size < pipe_size)? (max_size): (pipe_size);
+
+    if (pipe_status == DEVDRV_USBF_PIPE_IDLE) {
+        usb0_api_function_set_pid_nak(pipe);
+        usb0_api_function_clear_pipe_status(pipe);
+
+        usb0_api_function_start_receive_transfer(pipe, pipe_size, recv_buffer);
+    } else {
+        status = EP_PENDING;
+    }
+
+    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 = usb0_api_function_check_pipe_status(pipe, bytes_read);
+    if (pipe_status == DEVDRV_USBF_PIPE_IDLE) {
+        return EP_COMPLETED;
+    }
+    if (pipe_status == DEVDRV_USBF_PIPE_DONE) {
+        return EP_COMPLETED;
+    }
+    if (pipe_status != DEVDRV_USBF_PIPE_WAIT) {
+        return status;
+    }
+
+    /* sets the output buffer and size */
+    g_usb0_function_data_pointer[pipe] = buffer;
+
+    /* receives data from pipe */
+    err = usb0_function_read_buffer(pipe);
+    recv_error = err;
+
+    pipe_status = usb0_api_function_check_pipe_status(pipe, bytes_read);
+    if (pipe_status == DEVDRV_USBF_PIPE_DONE) {
+        status = EP_COMPLETED;
+    }
+
+    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 = usb0_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 = usb0_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 = usb0_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 = usb0_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:
+            usb0_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);
+
+    usb0_function_clear_pid_stall(pipe);
+}
+
+
+/*************************************************************************/
+void USBHAL::unstallEndpoint(uint8_t endpoint)
+{
+    uint32_t pipe = EP2PIPE(endpoint);
+
+    usb0_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 = USB200.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 = USB200.BRDYSTS;
+    int_sts2 = USB200.NRDYSTS;
+    int_sts3 = USB200.BEMPSTS;
+    int_enb0 = USB200.INTENB0;
+    int_enb2 = USB200.BRDYENB;
+    int_enb3 = USB200.NRDYENB;
+    int_enb4 = USB200.BEMPENB;
+
+    if ((int_sts0 & USB_FUNCTION_BITRESM) &&
+            (int_enb0 & USB_FUNCTION_BITRSME)) {
+        USB200.INTSTS0 = (uint16_t)~USB_FUNCTION_BITRESM;
+        RZA_IO_RegWrite_16(&USB200.INTENB0, 0, USB_INTENB0_RSME_SHIFT, USB_INTENB0_RSME);
+        /*usb0_function_USB_FUNCTION_Resume();*/
+        suspendStateChanged(1);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITVBINT) &&
+        (int_enb0 & USB_FUNCTION_BITVBSE)) {
+        USB200.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVBINT;
+
+        if (usb0_function_CheckVBUStaus() == DEVDRV_USBF_ON) {
+            usb0_function_USB_FUNCTION_Attach();
+        } else {
+            usb0_function_USB_FUNCTION_Detach();
+        }
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITSOFR) &&
+        (int_enb0 & USB_FUNCTION_BITSOFE)) {
+        USB200.INTSTS0 = (uint16_t)~USB_FUNCTION_BITSOFR;
+        SOF((USB200.FRMNUM & USB_FRMNUM_FRNM) >> USB_FRMNUM_FRNM_SHIFT);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITDVST) &&
+        (int_enb0 & USB_FUNCTION_BITDVSE)) {
+        USB200.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: usb0_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
+                 *****************************************************************************/
+                usb0_function_init_status();            /* memory clear */
+
+#if 0
+                /* You would program those steps in USBCallback_busReset
+                 * if the system need the comment out steps.
+                 */
+
+                if (usb0_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED) {
+                    /* Device Descriptor reset */
+                    usb0_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED);
+                } else {
+                    /* Device Descriptor reset */
+                    usb0_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED);
+                }
+#endif
+                /* Default Control PIPE reset */
+                /*****************************************************************************
+                 * Function Name: usb0_function_ResetDCP
+                 * Description  : Initializes the default control pipe(DCP).
+                 * Outline      : Reset default control pipe
+                 * Arguments    : none
+                 * Return Value : none
+                 *****************************************************************************/
+                USB200.DCPCFG  = 0;
+                USB200.DCPMAXP = 64;    /*TODO: This value is copied from sample*/
+
+                USB200.CFIFOSEL  = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
+                USB200.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
+                USB200.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);
+                /*usb0_function_USB_FUNCTION_Suspend();*/
+                break;
+
+            default:
+                break;
+        }
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITBEMP) &&
+        (int_enb0 & USB_FUNCTION_BITBEMP) &&
+        ((int_sts3 & int_enb4) & g_usb0_function_bit_set[USB_FUNCTION_PIPE0])) {
+        /* ==== BEMP PIPE0 ==== */
+        usb0_function_BEMPInterruptPIPE0(int_sts3, int_enb4);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITBRDY) &&
+        (int_enb0 & USB_FUNCTION_BITBRDY) &&
+        ((int_sts1 & int_enb2) & g_usb0_function_bit_set[USB_FUNCTION_PIPE0])) {
+        /* ==== BRDY PIPE0 ==== */
+        usb0_function_BRDYInterruptPIPE0(int_sts1, int_enb2);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITNRDY) &&
+        (int_enb0 & USB_FUNCTION_BITNRDY) &&
+        ((int_sts2 & int_enb3) & g_usb0_function_bit_set[USB_FUNCTION_PIPE0])) {
+        /* ==== NRDY PIPE0 ==== */
+        usb0_function_NRDYInterruptPIPE0(int_sts2, int_enb3);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITCTRT) && (int_enb0 & USB_FUNCTION_BITCTRE)) {
+        int_sts0 = USB200.INTSTS0;
+        USB200.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 */
+            usb0_function_save_request();
+            if ((USB200.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 = USB200.INTSTS0;
+                dumy_sts = USB200.INTSTS0;
+                dumy_sts = USB200.INTSTS0;
+                return;
+            }
+        }
+
+        switch (int_sts0 & USB_FUNCTION_BITCTSQ) {
+            case USB_FUNCTION_CS_IDST:
+                if (g_usb0_function_TestModeFlag == DEVDRV_USBF_YES) {
+                    /* ==== Test Mode ==== */
+                    usb0_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 */
+                usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);
+
+                RZA_IO_RegWrite_16(&USB200.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL);
+                break;
+
+            case USB_FUNCTION_CS_RDSS:
+                RZA_IO_RegWrite_16(&USB200.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL);
+                break;
+
+            case USB_FUNCTION_CS_WRSS:
+                RZA_IO_RegWrite_16(&USB200.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL);
+                break;
+
+            case USB_FUNCTION_CS_SQER:
+                usb0_function_set_pid_stall(USB_FUNCTION_PIPE0);
+                break;
+
+            default:
+                usb0_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 ==== */
+        usb0_function_BEMPInterrupt(int_sts3, int_enb4);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITBRDY) &&
+        (int_enb0 & USB_FUNCTION_BITBRDY) &&
+        (int_sts1 & int_enb2) ) {
+        /* ==== BRDY PIPEx ==== */
+        usb0_function_BRDYInterrupt(int_sts1, int_enb2);
+    } else if (
+        (int_sts0 & USB_FUNCTION_BITNRDY) &&
+        (int_enb0 & USB_FUNCTION_BITNRDY) &&
+        (int_sts2 & int_enb3)) {
+        /* ==== NRDY PIPEx ==== */
+        usb0_function_NRDYInterrupt(int_sts2, int_enb3);
+    } else {
+        /* Do Nothing */
+    }
+
+    /* Three dummy reads for cleearing interrupt requests */
+    dumy_sts = USB200.INTSTS0;
+    dumy_sts = USB200.INTSTS1;
+}
+
+/*************************************************************************/
+#endif
+/*************************************************************************/
+/*EOF*/