ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[RZ/A1H] Supports the CDC of USB Function

pull/594/head
AMANUMA Kazuhisa 2014-10-24 18:07:52 +09:00
parent b5cd75cd56
commit 462a657337
22 changed files with 10949 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

367
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h Normal file
View File

@ -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 */

171
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function.h Normal file
View File

@ -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 */

104
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function_api.h Normal file
View File

@ -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 */

142
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb0_function_dmacdrv.h Normal file
View File

@ -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 */

143
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h Normal file
View File

@ -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 */

32
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h Normal file
View File

@ -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 */

2933
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_dataio.c Normal file
View File

File diff suppressed because it is too large Load Diff

346
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_dma.c Normal file
View File

@ -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 */

249
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_intrn.c Normal file
View File

@ -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 */

2024
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/common/usb0_function_lib.c Normal file
View File

File diff suppressed because it is too large Load Diff

439
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_api.c Normal file
View File

@ -0,0 +1,439 @@
/*******************************************************************************
* 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
*******************************************************************************/
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 */
}
/*******************************************************************************
* 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 */

142
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_controlrw.c Normal file
View File

@ -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 */

144
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_global.c Normal file
View File

@ -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 */

330
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_sig.c Normal file
View File

@ -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 */

453
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/function/usb0_function_sub.c Normal file
View File

@ -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 */

200
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/rza_io_regrw.c Normal file
View File

@ -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 */

698
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/usb0_function_dmacdrv.c Normal file
View File

@ -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 */

762
libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/src/userdef/usb0_function_userdef.c Normal file
View File

@ -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 *)(0x40000000))
/* #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 */

4
libraries/USBDevice/USBDevice/USBEndpoints.h
View File

@ -41,10 +41,12 @@ typedef enum {
#include "USBEndpoints_LPC17_LPC23.h"
#elif defined(TARGET_LPC11UXX) || defined(TARGET_LPC1347) || defined (TARGET_LPC11U6X) || defined (TARGET_LPC1549)
#include "USBEndpoints_LPC11U.h"
#elif defined(TARGET_KL25Z) | defined(TARGET_KL43Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D5M) | defined(TARGET_K64F)
#elif defined(TARGET_KL25Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D5M) | defined(TARGET_K64F)
#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

79
libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h Normal file
View File

@ -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*/

37
libraries/USBDevice/USBDevice/USBHAL.h
View File

@ -23,6 +23,14 @@
#include "USBEndpoints.h"
#include "toolchain.h"
#ifdef TARGET_RZ_A1H
#include "devdrv_usb_function_api.h"
#include "usb0_function.h"
#include "iobitmasks/usb_iobitmask.h"
#include "rza_io_regrw.h"
#include "USBDevice_Types.h"
#endif
//#ifdef __GNUC__
//#define __packed __attribute__ ((__packed__))
//#endif
@ -59,6 +67,19 @@ public:
bool getEndpointStallState(unsigned char endpoint);
uint32_t endpointReadcore(uint8_t endpoint, uint8_t *buffer);
#if defined(TARGET_RZ_A1H)
static USBHAL * instance;
static void _usbisr(void);
#endif
#ifdef TARGET_RZ_A1H
uint32_t EP2PIPE(uint8_t endpoint);
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);
#endif
protected:
virtual void busReset(void){};
virtual void EP0setupCallback(void){};
@ -105,8 +126,24 @@ protected:
private:
void usbisr(void);
#if !defined(TARGET_RZ_A1H)
static void _usbisr(void);
static USBHAL * instance;
#endif
#ifdef TARGET_RZ_A1H
IRQn_Type int_id; /* interrupt ID */
uint16_t int_level; /* initerrupt level */
uint16_t clock_mode; /* input clock selector */
uint16_t mode; /* USB speed (HIGH/FULL) */
DigitalOut *usb0_en;
uint16_t EP0_read_status;
uint16_t EPx_read_status;
void EP0setupControl(void);
#endif
#if defined(TARGET_LPC11UXX) || defined(TARGET_LPC11U6X) || defined(TARGET_LPC1347) || defined(TARGET_LPC1549)
bool (USBHAL::*epCallback[10 - 2])(void);

1151
libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp Normal file
View File

File diff suppressed because it is too large Load Diff