diff options
| author | Nick Sanders <nsanders@chromium.org> | 2016-08-02 19:35:44 -0700 |
|---|---|---|
| committer | chrome-bot <chrome-bot@chromium.org> | 2016-09-01 22:56:22 -0700 |
| commit | a4bfc663a3cd645b43963bb814269efe864f8d1e (patch) | |
| tree | 185ab7cc413c4b580ea50845a024838aba577732 /chip | |
| parent | 54f4612764e07e5e3ccd8a4af04ee83a46454612 (diff) | |
| download | chrome-ec-a4bfc663a3cd645b43963bb814269efe864f8d1e.tar.gz | |
sweetberry: add dwc usb support
stm32f446 uses a synopsys designware USB block
rather than the typical ST one. This change adds driver support
for the new block, including usb console support.
BUG=chromium:608039
TEST=usb console works
BRANCH=None
Change-Id: I0e143758ae0b5285f1c94ea2ec5aee159e22e00c
Signed-off-by: Nick Sanders <nsanders@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/365448
Reviewed-by: Randall Spangler <rspangler@chromium.org>
Diffstat (limited to 'chip')
| -rw-r--r-- | chip/stm32/build.mk | 10 | ||||
| -rw-r--r-- | chip/stm32/usb_dwc.c | 1230 | ||||
| -rw-r--r-- | chip/stm32/usb_dwc_console.c | 363 | ||||
| -rw-r--r-- | chip/stm32/usb_dwc_console.h | 13 | ||||
| -rw-r--r-- | chip/stm32/usb_dwc_hw.h | 45 | ||||
| -rw-r--r-- | chip/stm32/usb_dwc_registers.h | 7530 | ||||
| -rw-r--r-- | chip/stm32/usb_hw.h | 6 |
7 files changed, 9196 insertions, 1 deletions
diff --git a/chip/stm32/build.mk b/chip/stm32/build.mk index d145db5473..3e1e11ab32 100644 --- a/chip/stm32/build.mk +++ b/chip/stm32/build.mk @@ -43,7 +43,6 @@ chip-$(CONFIG_STREAM_USART)+=usart_rx_interrupt-$(CHIP_FAMILY).o chip-$(CONFIG_STREAM_USART)+=usart_tx_interrupt.o chip-$(CONFIG_STREAM_USART)+=usart_rx_dma.o usart_tx_dma.o chip-$(CONFIG_CMD_USART_INFO)+=usart_info_command.o -chip-$(CONFIG_STREAM_USB)+=usb-stream.o chip-$(CONFIG_WATCHDOG)+=watchdog.o chip-$(HAS_TASK_CONSOLE)+=uart.o chip-$(HAS_TASK_KEYSCAN)+=keyboard_raw.o @@ -57,6 +56,14 @@ chip-$(CONFIG_ADC)+=adc-$(CHIP_FAMILY).o chip-$(CONFIG_STM32_CHARGER_DETECT)+=charger_detect.o chip-$(CONFIG_DEBUG_PRINTF)+=debug_printf.o chip-$(CONFIG_PWM)+=pwm.o + +ifeq ($(CHIP_FAMILY),stm32f4) +chip-$(CONFIG_USB)+=usb_dwc.o usb_endpoints.o +chip-$(CONFIG_USB_CONSOLE)+=usb_dwc_console.o +chip-$(CONFIG_STREAM_USB)+=usb_dwc_stream.o +chip-$(CONFIG_USB_I2C)+=usb_dwc_i2c.o +else +chip-$(CONFIG_STREAM_USB)+=usb-stream.o chip-$(CONFIG_USB)+=usb.o usb-$(CHIP_FAMILY).o usb_endpoints.o chip-$(CONFIG_USB_CONSOLE)+=usb_console.o chip-$(CONFIG_USB_GPIO)+=usb_gpio.o @@ -64,3 +71,4 @@ chip-$(CONFIG_USB_HID)+=usb_hid.o chip-$(CONFIG_USB_PD_TCPC)+=usb_pd_phy.o chip-$(CONFIG_USB_SPI)+=usb_spi.o chip-$(CONFIG_USB_I2C)+=usb_i2c.o +endif diff --git a/chip/stm32/usb_dwc.c b/chip/stm32/usb_dwc.c new file mode 100644 index 0000000000..628a0c1406 --- /dev/null +++ b/chip/stm32/usb_dwc.c @@ -0,0 +1,1230 @@ +/* Copyright 2016 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "clock.h" +#include "common.h" +#include "config.h" +#include "console.h" +#include "flash.h" +#include "gpio.h" +#include "hooks.h" +#include "link_defs.h" +#include "registers.h" +#include "usb_dwc_hw.h" +#include "system.h" +#include "task.h" +#include "timer.h" +#include "util.h" +#include "usb_descriptor.h" +#include "watchdog.h" + + +/****************************************************************************/ +/* Debug output */ + +/* Console output macro */ +#define CPRINTS(format, args...) cprints(CC_USB, format, ## args) +#define CPRINTF(format, args...) cprintf(CC_USB, format, ## args) + +/* TODO: Something unexpected happened. Figure out how to report & fix it. */ +#define report_error(val) \ + CPRINTS("Unhandled USB event at %s line %d: 0x%x", \ + __FILE__, __LINE__, val) + + +/****************************************************************************/ +/* Standard USB stuff */ + +#ifdef CONFIG_USB_BOS +/* v2.01 (vs 2.00) BOS Descriptor provided */ +#define USB_DEV_BCDUSB 0x0201 +#else +#define USB_DEV_BCDUSB 0x0200 +#endif + +#ifndef USB_DEV_CLASS +#define USB_DEV_CLASS USB_CLASS_PER_INTERFACE +#endif + +#ifndef CONFIG_USB_BCD_DEV +#define CONFIG_USB_BCD_DEV 0x0100 /* 1.00 */ +#endif + +#ifndef USB_BMATTRIBUTES +#ifdef CONFIG_USB_SELF_POWERED +#define USB_BMATTRIBUTES 0xc0 /* Self powered. */ +#else +#define USB_BMATTRIBUTES 0x80 /* Bus powered. */ +#endif +#endif + +#ifndef CONFIG_USB_SERIALNO +#define USB_STR_SERIALNO 0 +#else +static int usb_load_serial(void); +#endif + + +/* USB Standard Device Descriptor */ +static const struct usb_device_descriptor dev_desc = { + .bLength = USB_DT_DEVICE_SIZE, + .bDescriptorType = USB_DT_DEVICE, + .bcdUSB = USB_DEV_BCDUSB, + .bDeviceClass = USB_DEV_CLASS, + .bDeviceSubClass = 0x00, + .bDeviceProtocol = 0x00, + .bMaxPacketSize0 = USB_MAX_PACKET_SIZE, + .idVendor = USB_VID_GOOGLE, + .idProduct = CONFIG_USB_PID, + .bcdDevice = CONFIG_USB_BCD_DEV, + .iManufacturer = USB_STR_VENDOR, + .iProduct = USB_STR_PRODUCT, + .iSerialNumber = USB_STR_SERIALNO, + .bNumConfigurations = 1 +}; + +/* USB Configuration Descriptor */ +const struct usb_config_descriptor USB_CONF_DESC(conf) = { + .bLength = USB_DT_CONFIG_SIZE, + .bDescriptorType = USB_DT_CONFIGURATION, + .wTotalLength = 0x0BAD, /* number of returned bytes, set at runtime */ + .bNumInterfaces = USB_IFACE_COUNT, + .bConfigurationValue = 1, /* Caution: hard-coded value */ + .iConfiguration = USB_STR_VERSION, + .bmAttributes = USB_BMATTRIBUTES, /* bus or self powered */ + .bMaxPower = (CONFIG_USB_MAXPOWER_MA / 2), +}; + +/* Qualifier Descriptor */ +static const struct usb_qualifier_descriptor qualifier_desc = { + .bLength = USB_DT_QUALIFIER_SIZE, + .bDescriptorType = USB_DT_DEVICE_QUALIFIER, + .bcdUSB = USB_DEV_BCDUSB, + .bDeviceClass = USB_DEV_CLASS, + .bDeviceSubClass = 0x00, + .bDeviceProtocol = 0x00, + .bMaxPacketSize0 = USB_MAX_PACKET_SIZE, + .bNumConfigurations = 1, + .bReserved = 0, +}; + +const uint8_t usb_string_desc[] = { + 4, /* Descriptor size */ + USB_DT_STRING, + 0x09, 0x04 /* LangID = 0x0409: U.S. English */ +}; + +/****************************************************************************/ +/* Packet-handling stuff, specific to this SoC */ + +/* Some internal state to keep track of what's going on */ +static enum { + WAITING_FOR_SETUP_PACKET, + DATA_STAGE_IN, + NO_DATA_STAGE, +} what_am_i_doing; + +#ifdef DEBUG_ME +static const char * const wat[3] = { + [WAITING_FOR_SETUP_PACKET] = "wait_for_setup", + [DATA_STAGE_IN] = "data_in", + [NO_DATA_STAGE] = "no_data", +}; +#endif + +/* Programmer's Guide, Table 10-7 */ +enum table_case { + BAD_0, + TABLE_CASE_COMPLETE, + TABLE_CASE_SETUP, + TABLE_CASE_WTF, + TABLE_CASE_D, + TABLE_CASE_E, + BAD_6, + BAD_7, +}; + +static enum table_case decode_table_10_7(uint32_t doepint) +{ + enum table_case val = BAD_0; + + /* Bits: SI, SPD, IOC */ + if (doepint & DOEPINT_XFERCOMPL) + val += 1; + if (doepint & DOEPINT_SETUP) + val += 2; + return val; +} + +/* For STATUS/OUT: Use two DMA descriptors, each with one-packet buffers */ +#define NUM_OUT_BUFFERS 2 +static uint8_t ep0_setup_buf[USB_MAX_PACKET_SIZE]; + +/* For IN: Several DMA descriptors, all pointing into one large buffer, so that + * we can return the configuration descriptor as one big blob. + */ +#define NUM_IN_PACKETS_AT_ONCE 4 +#define IN_BUF_SIZE (NUM_IN_PACKETS_AT_ONCE * USB_MAX_PACKET_SIZE) +static uint8_t ep0_in_buf[IN_BUF_SIZE]; + +struct dwc_usb_ep ep0_ctl = { + .max_packet = USB_MAX_PACKET_SIZE, + .tx_fifo = 0, + .out_pending = 0, + .out_data = 0, + .out_databuffer = ep0_setup_buf, + .out_databuffer_max = sizeof(ep0_setup_buf), + .in_packets = 0, + .in_pending = 0, + .in_data = 0, + .in_databuffer = ep0_in_buf, + .in_databuffer_max = sizeof(ep0_in_buf), +}; + +/* Overall device state (USB 2.0 spec, section 9.1.1). + * We only need a few, though. + */ +static enum { + DS_DEFAULT, + DS_ADDRESS, + DS_CONFIGURED, +} device_state; +static uint8_t configuration_value; + +static void flush_all_fifos(void) +{ + /* Flush all FIFOs according to Section 2.1.1.2 */ + GR_USB_GRSTCTL = GRSTCTL_TXFNUM(0x10) | GRSTCTL_TXFFLSH + | GRSTCTL_RXFFLSH; + while (GR_USB_GRSTCTL & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH)) + ; +} + +int send_in_packet(uint32_t ep_num) +{ + struct dwc_usb *usb = &usb_ctl; + struct dwc_usb_ep *ep = usb->ep[ep_num]; + int len = MIN(USB_MAX_PACKET_SIZE, ep->in_pending); + + if (ep->in_packets == 0) { + report_error(ep_num); + return -1; + } + + GR_USB_DIEPTSIZ(0) = 0; + + GR_USB_DIEPTSIZ(0) |= DXEPTSIZ_PKTCNT(1); + GR_USB_DIEPTSIZ(0) |= DXEPTSIZ_XFERSIZE(len); + GR_USB_DIEPDMA(0) = (uint32_t)ep->in_data; + + + /* We're sending this much. */ + ep->in_pending -= len; + ep->in_packets -= 1; + ep->in_data += len; + + /* We are ready to enable this endpoint to start transferring data. */ + return len; +} + + +/* Load the EP0 IN FIFO buffer with some data (zero-length works too). Returns + * len, or negative on error. + */ +int initialize_in_transfer(const void *source, uint32_t len) +{ + struct dwc_usb *usb = &usb_ctl; + struct dwc_usb_ep *ep = usb->ep[0]; + +#ifdef CONFIG_USB_DWC_FS + /* FS OTG port does not support DMA or external phy */ + ASSERT(!(usb->dma_en)); + ASSERT(usb->phy_type == USB_PHY_INTERNAL); + ASSERT(usb->speed == USB_SPEED_FS); + ASSERT(usb->irq == STM32_IRQ_OTG_FS); +#else + /* HS OTG port requires an external phy to support HS */ + ASSERT(!((usb->phy_type == USB_PHY_INTERNAL) && + (usb->speed == USB_SPEED_HS))); + ASSERT(usb->irq == STM32_IRQ_OTG_HS); +#endif + + /* Copy the data into our FIFO buffer */ + if (len >= IN_BUF_SIZE) { + report_error(len); + return -1; + } + + /* Stage data in DMA buffer. */ + memcpy(ep->in_databuffer, source, len); + ep->in_data = ep->in_databuffer; + + /* We will send as many packets as necessary, including a final + * packet of < USB_MAX_PACKET_SIZE (maybe zero length) + */ + ep->in_packets = (len + USB_MAX_PACKET_SIZE)/USB_MAX_PACKET_SIZE; + ep->in_pending = len; + + send_in_packet(0); + return len; +} + +/* Prepare the EP0 OUT FIFO buffer to accept some data. Returns len, or + * negative on error. + */ +int accept_out_fifo(uint32_t len) +{ + /* TODO: This is not yet implemented */ + report_error(len); + return -1; +} + +/* The next packet from the host should be a Setup packet. Get ready for it. */ +static void expect_setup_packet(void) +{ + struct dwc_usb *usb = &usb_ctl; + struct dwc_usb_ep *ep = usb->ep[0]; + + what_am_i_doing = WAITING_FOR_SETUP_PACKET; + ep->out_data = ep->out_databuffer; + + /* We don't care about IN packets right now, only OUT. */ + GR_USB_DAINTMSK |= DAINT_OUTEP(0); + GR_USB_DAINTMSK &= ~DAINT_INEP(0); + + GR_USB_DOEPTSIZ(0) = 0; + GR_USB_DOEPTSIZ(0) |= DXEPTSIZ_PKTCNT(1); + GR_USB_DOEPTSIZ(0) |= DXEPTSIZ_XFERSIZE(0x18); + GR_USB_DOEPTSIZ(0) |= DXEPTSIZ_SUPCNT(1); + GR_USB_DOEPCTL(0) = DXEPCTL_USBACTEP | DXEPCTL_EPENA; + GR_USB_DOEPDMA(0) = (uint32_t)ep->out_data; +} + +/* We're complaining about something by stalling both IN and OUT packets, + * but a SETUP packet will get through anyway, so prepare for it. + */ +static void stall_both_fifos(void) +{ + what_am_i_doing = WAITING_FOR_SETUP_PACKET; + /* We don't care about IN packets right now, only OUT. */ + GR_USB_DAINTMSK |= DAINT_OUTEP(0); + GR_USB_DAINTMSK &= ~DAINT_INEP(0); + + GR_USB_DOEPCTL(0) |= DXEPCTL_STALL; + GR_USB_DIEPCTL(0) |= DXEPCTL_STALL; + expect_setup_packet(); +} + +/* The TX FIFO buffer is loaded. Start the Data phase. */ +static void expect_data_phase_in(enum table_case tc) +{ + what_am_i_doing = DATA_STAGE_IN; + + /* Send the reply (data phase in) */ + if (tc == TABLE_CASE_SETUP) + GR_USB_DIEPCTL(0) |= DXEPCTL_USBACTEP | + DXEPCTL_CNAK | DXEPCTL_EPENA; + else + GR_USB_DIEPCTL(0) |= DXEPCTL_EPENA; + + /* We'll receive an empty packet back as a ack, I guess. */ + if (tc == TABLE_CASE_SETUP) + GR_USB_DOEPCTL(0) |= DXEPCTL_CNAK | DXEPCTL_EPENA; + else + GR_USB_DOEPCTL(0) |= DXEPCTL_EPENA; + + /* Get an interrupt when either IN or OUT arrives */ + GR_USB_DAINTMSK |= (DAINT_OUTEP(0) | DAINT_INEP(0)); + +} + +static void expect_data_phase_out(enum table_case tc) +{ + /* TODO: This is not yet supported */ + report_error(tc); + expect_setup_packet(); +} + +/* No Data phase, just Status phase (which is IN, since Setup is OUT) */ +static void expect_status_phase_in(enum table_case tc) +{ + what_am_i_doing = NO_DATA_STAGE; + + /* Expect a zero-length IN for the Status phase */ + (void) initialize_in_transfer(0, 0); + + /* Blindly following instructions here, too. */ + if (tc == TABLE_CASE_SETUP) + GR_USB_DIEPCTL(0) |= DXEPCTL_USBACTEP + | DXEPCTL_CNAK | DXEPCTL_EPENA; + else + GR_USB_DIEPCTL(0) |= DXEPCTL_EPENA; + + /* Get an interrupt when either IN or OUT arrives */ + GR_USB_DAINTMSK |= (DAINT_OUTEP(0) | DAINT_INEP(0)); +} + +/* Handle a Setup packet that expects us to send back data in reply. Return the + * length of the data we're returning, or negative to indicate an error. + */ +static int handle_setup_with_in_stage(enum table_case tc, + struct usb_setup_packet *req) +{ + struct dwc_usb *usb = &usb_ctl; + struct dwc_usb_ep *ep = usb->ep[0]; + + const void *data = 0; + uint32_t len = 0; + int ugly_hack = 0; + static const uint16_t zero; /* == 0 */ + + switch (req->bRequest) { + case USB_REQ_GET_DESCRIPTOR: { + uint8_t type = req->wValue >> 8; + uint8_t idx = req->wValue & 0xff; + + switch (type) { + case USB_DT_DEVICE: + data = &dev_desc; + len = sizeof(dev_desc); + break; + case USB_DT_CONFIGURATION: + data = __usb_desc; + len = USB_DESC_SIZE; + ugly_hack = 1; /* see below */ + break; +#ifdef CONFIG_USB_BOS + case USB_DT_BOS: + data = bos_ctx.descp; + len = bos_ctx.size; + break; +#endif + case USB_DT_STRING: + if (idx >= USB_STR_COUNT) + return -1; +#ifdef CONFIG_USB_SERIALNO + if (idx == USB_STR_SERIALNO) + data = (uint8_t *)usb_serialno_desc; + else +#endif + data = usb_strings[idx]; + len = *(uint8_t *)data; + break; + case USB_DT_DEVICE_QUALIFIER: + /* We're not high speed */ + return -1; + default: + report_error(type); + return -1; + } + break; + } + case USB_REQ_GET_STATUS: { + /* TODO: Device Status: Remote Wakeup? Self Powered? */ + data = &zero; + len = sizeof(zero); + break; + } + case USB_REQ_GET_CONFIGURATION: + data = &configuration_value; + len = sizeof(configuration_value); + break; + + case USB_REQ_SYNCH_FRAME: + /* Unimplemented */ + return -1; + + default: + report_error(req->bRequest); + return -1; + } + + /* Don't send back more than we were asked for. */ + len = MIN(req->wLength, len); + + /* Prepare the TX FIFO. If we haven't preallocated enough room in the + * TX FIFO for the largest reply, we'll have to stall. This is a bug in + * our code, but detecting it easily at compile time is related to the + * ugly_hack directly below. + */ + if (initialize_in_transfer(data, len) < 0) + return -1; + + if (ugly_hack) { + /* + * TODO: Somebody figure out how to fix this, please. + * + * The USB configuration descriptor request is unique in that + * it not only returns the configuration descriptor, but also + * all the interface descriptors and all their endpoint + * descriptors as one enormous blob. We've set up some macros + * so we can declare and implement separate interfaces in + * separate files just by compiling them, and all the relevant + * descriptors are sorted and bundled up by the linker. But the + * total length of the entire blob needs to appear in the first + * configuration descriptor struct and because we don't know + * that value until after linking, it can't be initialized as a + * constant. So we have to compute it at run-time and shove it + * in here, which also means that we have to copy the whole + * blob into our TX FIFO buffer so that it's mutable. Otherwise + * we could just point at it (or pretty much any other constant + * struct that we wanted to send to the host). Bah. + */ + struct usb_config_descriptor *cfg = + (struct usb_config_descriptor *)ep->in_databuffer; + /* set the real descriptor size */ + cfg->wTotalLength = USB_DESC_SIZE; + } + + return len; +} + +/* Handle a Setup that comes with additional data for us. */ +static int handle_setup_with_out_stage(enum table_case tc, + struct usb_setup_packet *req) +{ + /* TODO: We don't support any of these. We should. */ + report_error(-1); + return -1; +} + +/* Some Setup packets don't have a data stage at all. */ +static int handle_setup_with_no_data_stage(enum table_case tc, + struct usb_setup_packet *req) +{ + uint8_t set_addr; + + switch (req->bRequest) { + case USB_REQ_SET_ADDRESS: + /* + * Set the address after the IN packet handshake. + * + * From the USB 2.0 spec, section 9.4.6: + * + * As noted elsewhere, requests actually may result in + * up to three stages. In the first stage, the Setup + * packet is sent to the device. In the optional second + * stage, data is transferred between the host and the + * device. In the final stage, status is transferred + * between the host and the device. The direction of + * data and status transfer depends on whether the host + * is sending data to the device or the device is + * sending data to the host. The Status stage transfer + * is always in the opposite direction of the Data + * stage. If there is no Data stage, the Status stage + * is from the device to the host. + * + * Stages after the initial Setup packet assume the + * same device address as the Setup packet. The USB + * device does not change its device address until + * after the Status stage of this request is completed + * successfully. Note that this is a difference between + * this request and all other requests. For all other + * requests, the operation indicated must be completed + * before the Status stage + */ + set_addr = req->wValue & 0xff; + /* + * NOTE: Now that we've said that, we don't do it. The + * hardware for this SoC knows that an IN packet will + * be following the SET ADDRESS, so it waits until it + * sees that happen before the address change takes + * effect. If we wait until after the IN packet to + * change the register, the hardware gets confused and + * doesn't respond to anything. + */ + GWRITE_FIELD(USB, DCFG, DEVADDR, set_addr); + CPRINTS("SETAD 0x%02x (%d)", set_addr, set_addr); + device_state = DS_ADDRESS; + break; + + case USB_REQ_SET_CONFIGURATION: + switch (req->wValue) { + case 0: + configuration_value = req->wValue; + device_state = DS_ADDRESS; + break; + case 1: /* Caution: Only one config descriptor TODAY */ + /* TODO: All endpoints set to DATA0 toggle state */ + configuration_value = req->wValue; + device_state = DS_CONFIGURED; + break; + default: + /* Nope. That's a paddlin. */ + report_error(-1); + return -1; + } + break; + + case USB_REQ_CLEAR_FEATURE: + case USB_REQ_SET_FEATURE: + /* TODO: Handle DEVICE_REMOTE_WAKEUP, ENDPOINT_HALT? */ + break; + + default: + /* Anything else is unsupported */ + report_error(-1); + return -1; + } + + /* No data to transfer, go straight to the Status phase. */ + return 0; +} + +/* Dispatch an incoming Setup packet according to its type */ +static void handle_setup(enum table_case tc) +{ + struct dwc_usb *usb = &usb_ctl; + struct dwc_usb_ep *ep = usb->ep[0]; + struct usb_setup_packet *req = + (struct usb_setup_packet *)ep->out_databuffer; + int data_phase_in = req->bmRequestType & USB_DIR_IN; + int data_phase_out = !data_phase_in && req->wLength; + int bytes = -1; /* default is to stall */ + + if (0 == (req->bmRequestType & (USB_TYPE_MASK | USB_RECIP_MASK))) { + /* Standard Device requests */ + if (data_phase_in) + bytes = handle_setup_with_in_stage(tc, req); + else if (data_phase_out) + bytes = handle_setup_with_out_stage(tc, req); + else + bytes = handle_setup_with_no_data_stage(tc, req); + } else if (USB_RECIP_INTERFACE == + (req->bmRequestType & USB_RECIP_MASK)) { + /* Interface-specific requests */ + uint8_t iface = req->wIndex & 0xff; + + if (iface < USB_IFACE_COUNT) + bytes = usb_iface_request[iface](req); + } else { + /* Something we need to add support for? */ + report_error(-1); + } + + /* We say "no" to unsupported and intentionally unhandled requests by + * stalling the Data and/or Status stage. + */ + if (bytes < 0) { + /* Stall both IN and OUT. SETUP will come through anyway. */ + stall_both_fifos(); + } else { + if (data_phase_in) + expect_data_phase_in(tc); + else if (data_phase_out) + expect_data_phase_out(tc); + else + expect_status_phase_in(tc); + } +} + +/* This handles both IN and OUT interrupts for EP0 */ +static void ep0_interrupt(uint32_t intr_on_out, uint32_t intr_on_in) +{ + struct dwc_usb *usb = &usb_ctl; + struct dwc_usb_ep *ep = usb->ep[0]; + uint32_t doepint, diepint; + enum table_case tc; + int out_complete, out_setup, in_complete; + + /* Determine the interrupt cause and clear the bits quickly, but only + * if they really apply. I don't think they're trustworthy if we didn't + * actually get an interrupt. + */ + doepint = GR_USB_DOEPINT(0) & GR_USB_DOEPMSK; + if (intr_on_out) + GR_USB_DOEPINT(0) = doepint; + diepint = GR_USB_DIEPINT(0) & GR_USB_DIEPMSK; + if (intr_on_in) + GR_USB_DIEPINT(0) = diepint; + + out_complete = doepint & DOEPINT_XFERCOMPL; + out_setup = doepint & DOEPINT_SETUP; + in_complete = diepint & DIEPINT_XFERCOMPL; + + /* Decode the situation according to Table 10-7 */ + tc = decode_table_10_7(doepint); + + switch (what_am_i_doing) { + case WAITING_FOR_SETUP_PACKET: + if (out_setup) + handle_setup(tc); + else + report_error(-1); + break; + + case DATA_STAGE_IN: + if (intr_on_in && in_complete) { + /* A packet is sent. Should we send another? */ + if (ep->in_packets > 0) { + /* Send another packet. */ + send_in_packet(0); + expect_data_phase_in(tc); + } + } + + /* But we should ignore the OUT endpoint if we didn't actually + * get an OUT interrupt. + */ + if (!intr_on_out) + break; + + if (out_setup) { + /* The first IN packet has been seen. Keep going. */ + break; + } + if (out_complete) { + /* We've handled the Status phase. All done. */ + expect_setup_packet(); + break; + } + + /* Anything else should be ignorable. Right? */ + break; + + case NO_DATA_STAGE: + if (intr_on_in && in_complete) { + /* We are not expecting an empty packet in + * return for our empty packet. + */ + expect_setup_packet(); + } + + /* Done unless we got an OUT interrupt */ + if (!intr_on_out) + break; + + if (out_setup) { + report_error(-1); + break; + } + + /* Anything else means get ready for a Setup packet */ + report_error(-1); + expect_setup_packet(); + break; + } +} + +/****************************************************************************/ +/* USB device initialization and shutdown routines */ + +/* + * DATA FIFO Setup. There is an internal SPRAM used to buffer the IN/OUT + * packets and track related state without hammering the AHB and system RAM + * during USB transactions. We have to specify where and how much of that SPRAM + * to use for what. + * + * See Programmer's Guide chapter 2, "Calculating FIFO Size". + * We're using Dedicated TxFIFO Operation, without enabling thresholding. + * + * Section 2.1.1.2, page 30: RXFIFO size is the same as for Shared FIFO, which + * is Section 2.1.1.1, page 28. This is also the same as Method 2 on page 45. + * + * We support up to 3 control EPs, no periodic IN EPs, up to 16 TX EPs. Max + * data packet size is 64 bytes. Total SPRAM available is 1024 slots. + */ +#define MAX_CONTROL_EPS 3 +#define MAX_NORMAL_EPS 16 +#define FIFO_RAM_DEPTH 1024 +/* + * Device RX FIFO size is thus: + * (4 * 3 + 6) + 2 * ((64 / 4) + 1) + (2 * 16) + 1 == 85 + */ +#define RXFIFO_SIZE ((4 * MAX_CONTROL_EPS + 6) + \ + 2 * ((USB_MAX_PACKET_SIZE / 4) + 1) + \ + (2 * MAX_NORMAL_EPS) + 1) +/* + * Device TX FIFO size is 2 * (64 / 4) == 32 for each IN EP (Page 46). + */ +#define TXFIFO_SIZE (2 * (USB_MAX_PACKET_SIZE / 4)) +/* + * We need 4 slots per endpoint direction for endpoint status stuff (Table 2-1, + * unconfigurable). + */ +#define EP_STATUS_SIZE (4 * MAX_NORMAL_EPS * 2) +/* + * Make sure all that fits. + */ +BUILD_ASSERT(RXFIFO_SIZE + TXFIFO_SIZE * MAX_NORMAL_EPS + EP_STATUS_SIZE < + FIFO_RAM_DEPTH); + + +/* Now put those constants into the correct registers */ +static void setup_data_fifos(void) +{ + int i; + + /* Programmer's Guide, p31 */ + GR_USB_GRXFSIZ = RXFIFO_SIZE; /* RXFIFO */ + GR_USB_GNPTXFSIZ = (TXFIFO_SIZE << 16) | RXFIFO_SIZE; /* TXFIFO 0 */ + + /* TXFIFO 1..15 */ + for (i = 1; i < MAX_NORMAL_EPS; i++) + GR_USB_DIEPTXF(i) = ((TXFIFO_SIZE << 16) | + (RXFIFO_SIZE + i * TXFIFO_SIZE)); + + /* + * TODO: The Programmer's Guide is confusing about when or whether to + * flush the FIFOs. Section 2.1.1.2 (p31) just says to flush. Section + * 2.2.2 (p55) says to stop all the FIFOs first, then flush. Section + * 7.5.4 (p162) says that flushing the RXFIFO at reset is not + * recommended at all. + * + * I'm also unclear on whether or not the individual EPs are expected + * to be disabled already (DIEPCTLn/DOEPCTLn.EPENA == 0), and if so, + * whether by firmware or hardware. + */ + + /* Flush all FIFOs according to Section 2.1.1.2 */ + GR_USB_GRSTCTL = GRSTCTL_TXFNUM(0x10) | GRSTCTL_TXFFLSH + | GRSTCTL_RXFFLSH; + while (GR_USB_GRSTCTL & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH)) + ; /* TODO: timeout 100ms */ +} + +static void usb_init_endpoints(void) +{ + int ep; + + /* Prepare to receive packets on EP0 */ + expect_setup_packet(); + + /* Reset the other endpoints */ + for (ep = 1; ep < USB_EP_COUNT; ep++) + usb_ep_reset[ep](); +} + +static void usb_reset(void) +{ + /* Clear our internal state */ + device_state = DS_DEFAULT; + configuration_value = 0; + + /* Clear the device address */ + GWRITE_FIELD(USB, DCFG, DEVADDR, 0); + + /* Reinitialize all the endpoints */ + usb_init_endpoints(); +} + +static void usb_resetdet(void) +{ + /* TODO: Same as normal reset, right? I think we only get this if we're + * suspended (sleeping) and the host resets us. Try it and see. + */ + usb_reset(); +} + +static void usb_enumdone(void) +{ + /* We can change to HS here. We will not go to HS today */ + GR_USB_DCTL |= DCTL_CGOUTNAK; +} + + +void usb_interrupt(void) +{ + uint32_t status = GR_USB_GINTSTS & GR_USB_GINTMSK; + uint32_t oepint = status & GINTSTS(OEPINT); + uint32_t iepint = status & GINTSTS(IEPINT); + int ep; + + if (status & GINTSTS(ENUMDONE)) + usb_enumdone(); + + if (status & GINTSTS(RESETDET)) + usb_resetdet(); + + if (status & GINTSTS(USBRST)) + usb_reset(); + + /* Endpoint interrupts */ + if (oepint || iepint) { + /* Note: It seems that the DAINT bits are only trustworthy for + * identifying interrupts when selected by the corresponding + * OEPINT and IEPINT bits from GINTSTS. + */ + uint32_t daint = GR_USB_DAINT; + + /* EP0 has a combined IN/OUT handler. Only call it once, but + * let it know which direction(s) had an interrupt. + */ + if (daint & (DAINT_OUTEP(0) | DAINT_INEP(0))) { + uint32_t intr_on_out = (oepint && + (daint & DAINT_OUTEP(0))); + uint32_t intr_on_in = (iepint && + (daint & DAINT_INEP(0))); + ep0_interrupt(intr_on_out, intr_on_in); + } + + /* Invoke the unidirectional IN and OUT functions for the other + * endpoints. Each handler must clear their own bits in + * DIEPINTn/DOEPINTn. + */ + for (ep = 1; ep < USB_EP_COUNT; ep++) { + if (oepint && (daint & DAINT_OUTEP(ep))) + usb_ep_rx[ep](); + if (iepint && (daint & DAINT_INEP(ep))) + usb_ep_tx[ep](); + } + } + + GR_USB_GINTSTS = status; +} +DECLARE_IRQ(STM32_IRQ_OTG_FS, usb_interrupt, 1); +DECLARE_IRQ(STM32_IRQ_OTG_HS, usb_interrupt, 1); + +static void usb_softreset(void) +{ + int timeout; + + CPRINTS("%s", __func__); + + /* Wait for bus idle */ + timeout = 10000; + while (!(GR_USB_GRSTCTL & GRSTCTL_AHBIDLE) && timeout-- > 0) + ; + + /* Reset and wait for clear */ + GR_USB_GRSTCTL = GRSTCTL_CSFTRST; + timeout = 10000; + while ((GR_USB_GRSTCTL & GRSTCTL_CSFTRST) && timeout-- > 0) + ; + if (GR_USB_GRSTCTL & GRSTCTL_CSFTRST) { + CPRINTF("USB: reset failed\n"); + return; + } + + /* Some more idle? */ + timeout = 10000; + while (!(GR_USB_GRSTCTL & GRSTCTL_AHBIDLE) && timeout-- > 0) + ; + + if (!timeout) { + CPRINTF("USB: reset timeout\n"); + return; + } + /* TODO: Wait 3 PHY clocks before returning */ +} + +void usb_connect(void) +{ + GR_USB_DCTL &= ~DCTL_SFTDISCON; +} + +void usb_disconnect(void) +{ + GR_USB_DCTL |= DCTL_SFTDISCON; + + device_state = DS_DEFAULT; + configuration_value = 0; +} + +void usb_reset_init_phy(void) +{ + struct dwc_usb *usb = &usb_ctl; + + if (usb->phy_type == USB_PHY_ULPI) { + GR_USB_GCCFG &= ~GCCFG_PWRDWN; + GR_USB_GUSBCFG &= ~(GUSBCFG_TSDPS | + GUSBCFG_ULPIFSLS | GUSBCFG_PHYSEL); + GR_USB_GUSBCFG &= ~(GUSBCFG_ULPIEVBUSD | GUSBCFG_ULPIEVBUSI); + /* No suspend */ + GR_USB_GUSBCFG |= GUSBCFG_ULPICSM | GUSBCFG_ULPIAR; + + usb_softreset(); + } else { + GR_USB_GUSBCFG |= GUSBCFG_PHYSEL; + usb_softreset(); + GR_USB_GCCFG |= GCCFG_PWRDWN; + } +} + +void usb_init(void) +{ + int i; + struct dwc_usb *usb = &usb_ctl; + + CPRINTS("%s", __func__); + +#ifdef CONFIG_USB_SERIALNO + usb_load_serial(); +#endif + + /* USB is in use */ + disable_sleep(SLEEP_MASK_USB_DEVICE); + + /* Enable clocks */ + clock_enable_module(MODULE_USB, 0); + clock_enable_module(MODULE_USB, 1); + + /* TODO(crbug.com/496888): set up pinmux */ + gpio_config_module(MODULE_USB, 1); + + /* Make sure interrupts are disabled */ + GR_USB_GINTMSK = 0; + GR_USB_DAINTMSK = 0; + GR_USB_DIEPMSK = 0; + GR_USB_DOEPMSK = 0; + + /* Full-Speed Serial PHY */ + usb_reset_init_phy(); + + /* Global + DMA configuration */ + GR_USB_GAHBCFG = GAHBCFG_GLB_INTR_EN; + GR_USB_GAHBCFG |= GAHBCFG_HBSTLEN_INCR4; + if (usb->dma_en) + GR_USB_GAHBCFG |= GAHBCFG_DMA_EN; + + /* Device only, no SRP */ + GR_USB_GUSBCFG |= GUSBCFG_FDMOD; + GR_USB_GUSBCFG |= GUSBCFG_SRPCAP | GUSBCFG_HNPCAP; + + GR_USB_GCCFG &= ~GCCFG_VBDEN; + GR_USB_GOTGCTL |= GOTGCTL_BVALOEN; + GR_USB_GOTGCTL |= GOTGCTL_BVALOVAL; + + GR_USB_PCGCCTL = 0; + + if (usb->phy_type == USB_PHY_ULPI) { + /* TODO(nsanders): add HS support like so. + * GR_USB_DCFG = (GR_USB_DCFG & ~GC_USB_DCFG_DEVSPD_MASK) + * | DCFG_DEVSPD_HSULPI; + */ + GR_USB_DCFG = (GR_USB_DCFG & ~GC_USB_DCFG_DEVSPD_MASK) + | DCFG_DEVSPD_FSULPI; + } else { + GR_USB_DCFG = (GR_USB_DCFG & ~GC_USB_DCFG_DEVSPD_MASK) + | DCFG_DEVSPD_FS48; + } + + GR_USB_DCFG |= DCFG_NZLSOHSK; + + flush_all_fifos(); + + /* Clear pending interrupts again */ + GR_USB_GINTMSK = 0; + GR_USB_DIEPMSK = 0; + GR_USB_DOEPMSK = 0; + GR_USB_DAINT = 0xffffffff; + GR_USB_DAINTMSK = 0; + + /* TODO: What about the AHB Burst Length Field? It's 0 now. */ + GR_USB_GAHBCFG |= GAHBCFG_TXFELVL | GAHBCFG_PTXFELVL; + + /* Device only, no SRP */ + GR_USB_GUSBCFG |= GUSBCFG_FDMOD + | GUSBCFG_TOUTCAL(7) + /* FIXME: Magic number! 14 is for 15MHz! Use 9 for 30MHz */ + | GUSBCFG_USBTRDTIM(14); + + /* Be in disconnected state until we are ready */ + usb_disconnect(); + + /* If we've restored a nonzero device address, update our state. */ + if (GR_USB_DCFG & GC_USB_DCFG_DEVADDR_MASK) { + /* Caution: We only have one config TODAY, so there's no real + * difference between DS_CONFIGURED and DS_ADDRESS. + */ + device_state = DS_CONFIGURED; + configuration_value = 1; + } else { + device_state = DS_DEFAULT; + configuration_value = 0; + } + + /* Now that DCFG.DesDMA is accurate, prepare the FIFOs */ + setup_data_fifos(); + + usb_init_endpoints(); + + /* Clear any pending interrupts */ + for (i = 0; i < 16; i++) { + GR_USB_DIEPINT(i) = 0xffffffff; + GR_USB_DIEPTSIZ(i) = 0; + GR_USB_DOEPINT(i) = 0xffffffff; + GR_USB_DOEPTSIZ(i) = 0; + } + + if (usb->dma_en) { + GR_USB_DTHRCTL = DTHRCTL_TXTHRLEN_6 | DTHRCTL_RXTHRLEN_6; + GR_USB_DTHRCTL |= DTHRCTL_RXTHREN | DTHRCTL_ISOTHREN + | DTHRCTL_NONISOTHREN; + i = GR_USB_DTHRCTL; + } + + GR_USB_GINTSTS = 0xFFFFFFFF; + + GR_USB_GAHBCFG |= GAHBCFG_GLB_INTR_EN | GAHBCFG_TXFELVL + | GAHBCFG_PTXFELVL; + + if (!(usb->dma_en)) + GR_USB_GINTMSK |= GINTMSK(RXFLVL); + + /* Unmask some endpoint interrupt causes */ + GR_USB_DIEPMSK = DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK; + GR_USB_DOEPMSK = DOEPMSK_EPDISBLDMSK | DOEPMSK_XFERCOMPLMSK | + DOEPMSK_SETUPMSK; + + /* Enable interrupt handlers */ + task_enable_irq(usb->irq); + + /* Allow USB interrupts to come in */ + GR_USB_GINTMSK |= + /* NAK bits that must be cleared by the DCTL register */ + GINTMSK(GOUTNAKEFF) | GINTMSK(GINNAKEFF) | + /* Initialization events */ + GINTMSK(USBRST) | GINTMSK(ENUMDONE) | + /* Reset detected while suspended. Need to wake up. */ + GINTMSK(RESETDET) | /* TODO: Do we need this? */ + /* Idle, Suspend detected. Should go to sleep. */ + GINTMSK(ERLYSUSP) | GINTMSK(USBSUSP); + + GR_USB_GINTMSK |= + /* Endpoint activity, cleared by the DOEPINT/DIEPINT regs */ + GINTMSK(OEPINT) | GINTMSK(IEPINT); + + /* Device registers have been setup */ + GR_USB_DCTL |= DCTL_PWRONPRGDONE; + udelay(10); + GR_USB_DCTL &= ~DCTL_PWRONPRGDONE; + + /* Clear global NAKs */ + GR_USB_DCTL |= DCTL_CGOUTNAK | DCTL_CGNPINNAK; + +#ifndef CONFIG_USB_INHIBIT_CONNECT + /* Indicate our presence to the USB host */ + usb_connect(); +#endif +} +#ifndef CONFIG_USB_INHIBIT_INIT +DECLARE_HOOK(HOOK_INIT, usb_init, HOOK_PRIO_DEFAULT); +#endif + +void usb_release(void) +{ + struct dwc_usb *usb = &usb_ctl; + + /* signal disconnect to host */ + usb_disconnect(); + + /* disable interrupt handlers */ + task_disable_irq(usb->irq); + + /* disable clocks */ + clock_enable_module(MODULE_USB, 0); + /* TODO: pin-mux */ + + /* USB is off, so sleep whenever */ + enable_sleep(SLEEP_MASK_USB_DEVICE); +} + +static int command_usb(int argc, char **argv) +{ + if (argc > 1) { + if (!strcasecmp("on", argv[1])) + usb_init(); + else if (!strcasecmp("off", argv[1])) + usb_release(); + } + + return EC_SUCCESS; +} +DECLARE_CONSOLE_COMMAND(usb, command_usb, + "[on|off|a|b]", + "Get/set the USB connection state and PHY selection"); + +#ifdef CONFIG_USB_SERIALNO +/* This will be subbed into USB_STR_SERIALNO. */ +struct usb_string_desc *usb_serialno_desc = + USB_WR_STRING_DESC(DEFAULT_SERIALNO); + +/* Update serial number */ +static int usb_set_serial(const char *serialno) +{ + struct usb_string_desc *sd = usb_serialno_desc; + int i; + + if (!serialno) + return EC_ERROR_INVAL; + + /* Convert into unicode usb string desc. */ + for (i = 0; i < USB_STRING_LEN; i++) { + sd->_data[i] = serialno[i]; + if (serialno[i] == 0) + break; + } + /* Count wchars (w/o null terminator) plus size & type bytes. */ + sd->_len = (i * 2) + 2; + sd->_type = USB_DT_STRING; + + return EC_SUCCESS; +} + +/* Retrieve serial number from pstate flash. */ +static int usb_load_serial(void) +{ + const char *serialno; + int rv; + + serialno = flash_read_serial(); + if (!serialno) + return EC_ERROR_ACCESS_DENIED; + + rv = usb_set_serial(serialno); + return rv; +} + + +/* Save serial number into pstate region. */ +static int usb_save_serial(const char *serialno) +{ + int rv; + + if (!serialno) + return EC_ERROR_INVAL; + + /* Save this new serial number to flash. */ + rv = flash_write_serial(serialno); + if (rv) + return rv; + + /* Load this new serial number to memory. */ + rv = usb_load_serial(); + return rv; +} + +static int command_serialno(int argc, char **argv) +{ + struct usb_string_desc *sd = usb_serialno_desc; + char buf[USB_STRING_LEN]; + int rv = EC_SUCCESS; + int i; + + if (argc != 1) { + if ((strcasecmp(argv[1], "set") == 0) && + (argc == 3)) { + ccprintf("Saving serial number\n"); + rv = usb_save_serial(argv[2]); + } else if ((strcasecmp(argv[1], "load") == 0) && + (argc == 2)) { + ccprintf("Loading serial number\n"); + rv = usb_load_serial(); + } else + return EC_ERROR_INVAL; + } + + for (i = 0; i < USB_STRING_LEN; i++) + buf[i] = sd->_data[i]; + ccprintf("Serial number: %s\n", buf); + return rv; +} + +DECLARE_CONSOLE_COMMAND(serialno, command_serialno, + "load/set [value]", + "Read and write USB serial number"); +#endif + diff --git a/chip/stm32/usb_dwc_console.c b/chip/stm32/usb_dwc_console.c new file mode 100644 index 0000000000..9e2e895ddb --- /dev/null +++ b/chip/stm32/usb_dwc_console.c @@ -0,0 +1,363 @@ +/* Copyright 2016 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "common.h" +#include "config.h" +#include "console.h" +#include "link_defs.h" +#include "printf.h" +#include "queue.h" +#include "registers.h" +#include "task.h" +#include "timer.h" +#include "util.h" +#include "usb_dwc_hw.h" +#include "usb_descriptor.h" + +/* Console output macro */ +#define CPRINTF(format, args...) cprintf(CC_USB, format, ## args) +#define USB_CONSOLE_TIMEOUT_US (30 * MSEC) + +static int last_tx_ok = 1; + +static int is_reset; +static int is_enabled = 1; +static int is_readonly; + +/* USB-Serial descriptors */ +const struct usb_interface_descriptor USB_IFACE_DESC(USB_IFACE_CONSOLE) = { + .bLength = USB_DT_INTERFACE_SIZE, + .bDescriptorType = USB_DT_INTERFACE, + .bInterfaceNumber = USB_IFACE_CONSOLE, + .bAlternateSetting = 0, + .bNumEndpoints = 2, + .bInterfaceClass = USB_CLASS_VENDOR_SPEC, + .bInterfaceSubClass = USB_SUBCLASS_GOOGLE_SERIAL, + .bInterfaceProtocol = USB_PROTOCOL_GOOGLE_SERIAL, + .iInterface = USB_STR_CONSOLE_NAME, +}; +const struct usb_endpoint_descriptor USB_EP_DESC(USB_IFACE_CONSOLE, 0) = { + .bLength = USB_DT_ENDPOINT_SIZE, + .bDescriptorType = USB_DT_ENDPOINT, + .bEndpointAddress = 0x80 | USB_EP_CONSOLE, + .bmAttributes = 0x02 /* Bulk IN */, + .wMaxPacketSize = USB_MAX_PACKET_SIZE, + .bInterval = 10 +}; +const struct usb_endpoint_descriptor USB_EP_DESC(USB_IFACE_CONSOLE, 1) = { + .bLength = USB_DT_ENDPOINT_SIZE, + .bDescriptorType = USB_DT_ENDPOINT, + .bEndpointAddress = USB_EP_CONSOLE, + .bmAttributes = 0x02 /* Bulk OUT */, + .wMaxPacketSize = USB_MAX_PACKET_SIZE, + .bInterval = 0 +}; + +static uint8_t ep_buf_tx[USB_MAX_PACKET_SIZE]; +static uint8_t ep_buf_rx[USB_MAX_PACKET_SIZE]; + +static struct queue const tx_q = QUEUE_NULL(256, uint8_t); +static struct queue const rx_q = QUEUE_NULL(USB_MAX_PACKET_SIZE, uint8_t); + + +struct dwc_usb_ep ep_console_ctl = { + .max_packet = USB_MAX_PACKET_SIZE, + .tx_fifo = USB_EP_CONSOLE, + .out_pending = 0, + .out_data = 0, + .out_databuffer = ep_buf_tx, + .out_databuffer_max = sizeof(ep_buf_tx), + .in_packets = 0, + .in_pending = 0, + .in_data = 0, + .in_databuffer = ep_buf_rx, + .in_databuffer_max = sizeof(ep_buf_rx), +}; + + + +/* Let the USB HW IN-to-host FIFO transmit some bytes */ +static void usb_enable_tx(int len) +{ + struct dwc_usb_ep *ep = &ep_console_ctl; + + ep->in_data = ep->in_databuffer; + ep->in_packets = 1; + ep->in_pending = len; + + GR_USB_DIEPTSIZ(USB_EP_CONSOLE) = 0; + + GR_USB_DIEPTSIZ(USB_EP_CONSOLE) |= DXEPTSIZ_PKTCNT(1); + GR_USB_DIEPTSIZ(USB_EP_CONSOLE) |= DXEPTSIZ_XFERSIZE(len); + GR_USB_DIEPDMA(USB_EP_CONSOLE) = (uint32_t)ep->in_data; + + GR_USB_DIEPCTL(USB_EP_CONSOLE) |= DXEPCTL_CNAK | DXEPCTL_EPENA; +} + +/* Let the USB HW OUT-from-host FIFO receive some bytes */ +static void usb_enable_rx(int len) +{ + struct dwc_usb_ep *ep = &ep_console_ctl; + + ep->out_data = ep->out_databuffer; + ep->out_pending = 0; + + GR_USB_DOEPTSIZ(USB_EP_CONSOLE) = 0; + GR_USB_DOEPTSIZ(USB_EP_CONSOLE) |= DXEPTSIZ_PKTCNT(1); + GR_USB_DOEPTSIZ(USB_EP_CONSOLE) |= DXEPTSIZ_XFERSIZE(len); + GR_USB_DOEPDMA(USB_EP_CONSOLE) = (uint32_t)ep->out_data; + + GR_USB_DOEPCTL(USB_EP_CONSOLE) |= DXEPCTL_CNAK | DXEPCTL_EPENA; +} + +/* True if the HW Rx/OUT FIFO has bytes for us. */ +static inline int rx_fifo_is_ready(void) +{ + struct dwc_usb_ep *ep = &ep_console_ctl; + + return ep->out_pending; +} + +/* + * This function tries to shove new bytes from the USB host into the queue for + * consumption elsewhere. It is invoked either by a HW interrupt (telling us we + * have new bytes from the USB host), or by whoever is reading bytes out of the + * other end of the queue (telling us that there's now more room in the queue + * if we still have bytes to shove in there). + */ +char buffer[65]; +static void rx_fifo_handler(void) +{ + struct dwc_usb_ep *ep = &ep_console_ctl; + + int rx_in_fifo; + size_t added; + + if (!rx_fifo_is_ready()) + return; + + rx_in_fifo = ep->out_pending; + added = QUEUE_ADD_UNITS(&rx_q, ep->out_databuffer, rx_in_fifo); + + if (added != rx_in_fifo) + CPRINTF("DROP CONSOLE: %d/%d process\n", added, rx_in_fifo); + + /* wake-up the console task */ + console_has_input(); + + usb_enable_rx(USB_MAX_PACKET_SIZE); +} +DECLARE_DEFERRED(rx_fifo_handler); + +/* Rx/OUT interrupt handler */ +static void con_ep_rx(void) +{ + struct dwc_usb_ep *ep = &ep_console_ctl; + + if (GR_USB_DOEPCTL(USB_EP_CONSOLE) & DXEPCTL_EPENA) + return; + + /* Bytes received decrement DOEPTSIZ XFERSIZE */ + if (GR_USB_DOEPINT(USB_EP_CONSOLE) & DOEPINT_XFERCOMPL) { + ep->out_pending = + ep->max_packet - + (GR_USB_DOEPTSIZ(USB_EP_CONSOLE) & + GC_USB_DOEPTSIZ1_XFERSIZE_MASK); + } + + /* Wake up the Rx FIFO handler */ + hook_call_deferred(&rx_fifo_handler_data, 0); + + /* clear the RX/OUT interrupts */ + GR_USB_DOEPINT(USB_EP_CONSOLE) = 0xffffffff; +} + +/* True if the Tx/IN FIFO can take some bytes from us. */ +static inline int tx_fifo_is_ready(void) +{ + return !(GR_USB_DIEPCTL(USB_EP_CONSOLE) & DXEPCTL_EPENA); +} + +/* Try to send some bytes to the host */ +static void tx_fifo_handler(void) +{ + struct dwc_usb_ep *ep = &ep_console_ctl; + size_t count; + + if (!is_reset) + return; + + /* If the HW FIFO isn't ready, then we can't do anything right now. */ + if (!tx_fifo_is_ready()) + return; + + count = QUEUE_REMOVE_UNITS(&tx_q, + ep->in_databuffer, USB_MAX_PACKET_SIZE); + if (count) + usb_enable_tx(count); +} +DECLARE_DEFERRED(tx_fifo_handler); + +static void handle_output(void) +{ + /* Wake up the Tx FIFO handler */ + hook_call_deferred(&tx_fifo_handler_data, 0); +} + +/* Tx/IN interrupt handler */ +static void con_ep_tx(void) +{ + /* Wake up the Tx FIFO handler */ + hook_call_deferred(&tx_fifo_handler_data, 0); + + /* clear the Tx/IN interrupts */ + GR_USB_DIEPINT(USB_EP_CONSOLE) = 0xffffffff; +} + +static void ep_reset(void) +{ + GR_USB_DOEPCTL(USB_EP_CONSOLE) = DXEPCTL_MPS(USB_MAX_PACKET_SIZE) | + DXEPCTL_USBACTEP | DXEPCTL_EPTYPE_BULK | + DXEPCTL_CNAK | DXEPCTL_EPENA; + GR_USB_DIEPCTL(USB_EP_CONSOLE) = DXEPCTL_MPS(USB_MAX_PACKET_SIZE) | + DXEPCTL_USBACTEP | DXEPCTL_EPTYPE_BULK | + DXEPCTL_TXFNUM(USB_EP_CONSOLE); + GR_USB_DAINTMSK |= DAINT_INEP(USB_EP_CONSOLE) | + DAINT_OUTEP(USB_EP_CONSOLE); + is_reset = 1; + + /* Flush any queued data */ + hook_call_deferred(&tx_fifo_handler_data, 0); + hook_call_deferred(&rx_fifo_handler_data, 0); + + usb_enable_rx(USB_MAX_PACKET_SIZE); +} + + +USB_DECLARE_EP(USB_EP_CONSOLE, con_ep_tx, con_ep_rx, ep_reset); + +static int usb_wait_console(void) +{ + timestamp_t deadline = get_time(); + int wait_time_us = 1; + + if (!is_enabled || !tx_fifo_is_ready()) + return EC_SUCCESS; + + deadline.val += USB_CONSOLE_TIMEOUT_US; + + /* + * If the USB console is not used, Tx buffer would never free up. + * In this case, let's drop characters immediately instead of sitting + * for some time just to time out. On the other hand, if the last + * Tx is good, it's likely the host is there to receive data, and + * we should wait so that we don't clobber the buffer. + */ + if (last_tx_ok) { + while (queue_space(&tx_q) < USB_MAX_PACKET_SIZE || !is_reset) { + if (timestamp_expired(deadline, NULL) || + in_interrupt_context()) { + last_tx_ok = 0; + return EC_ERROR_TIMEOUT; + } + if (wait_time_us < MSEC) + udelay(wait_time_us); + else + usleep(wait_time_us); + wait_time_us *= 2; + } + + return EC_SUCCESS; + } + + last_tx_ok = queue_space(&tx_q); + return EC_SUCCESS; +} +static int __tx_char(void *context, int c) +{ + struct queue *state = + (struct queue *) context; + + if (c == '\n' && __tx_char(state, '\r')) + return 1; + + QUEUE_ADD_UNITS(state, &c, 1); + return 0; +} + +/* + * Public USB console implementation below. + */ +int usb_getc(void) +{ + int c; + + if (!is_enabled) + return -1; + + if (QUEUE_REMOVE_UNITS(&rx_q, &c, 1)) + return c; + + return -1; +} + +int usb_puts(const char *outstr) +{ + int ret; + struct queue state; + + if (is_readonly) + return EC_SUCCESS; + + ret = usb_wait_console(); + if (ret) + return ret; + + state = tx_q; + while (*outstr) + if (__tx_char(&state, *outstr++)) + break; + + if (queue_count(&state)) + handle_output(); + + return *outstr ? EC_ERROR_OVERFLOW : EC_SUCCESS; +} + +int usb_putc(int c) +{ + char string[2]; + + string[0] = c; + string[1] = '\0'; + return usb_puts(string); +} + +int usb_vprintf(const char *format, va_list args) +{ + int ret; + struct queue state; + + if (is_readonly) + return EC_SUCCESS; + + ret = usb_wait_console(); + if (ret) + return ret; + + state = tx_q; + ret = vfnprintf(__tx_char, &state, format, args); + + if (queue_count(&state)) + handle_output(); + + return ret; +} + +void usb_console_enable(int enabled, int readonly) +{ + is_enabled = enabled; + is_readonly = readonly; +} diff --git a/chip/stm32/usb_dwc_console.h b/chip/stm32/usb_dwc_console.h new file mode 100644 index 0000000000..387a8f0543 --- /dev/null +++ b/chip/stm32/usb_dwc_console.h @@ -0,0 +1,13 @@ +/* Copyright 2016 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef __CHIP_STM32_USB_DWC_CONSOLE_H +#define __CHIP_STM32_USB_DWC_CONSOLE_H + +#include "usb_dwc_hw.h" + +extern struct dwc_usb_ep ep_console_ctl; + +#endif /* __CHIP_STM32_USB_DWC_CONSOLE_H */ diff --git a/chip/stm32/usb_dwc_hw.h b/chip/stm32/usb_dwc_hw.h new file mode 100644 index 0000000000..36361ab371 --- /dev/null +++ b/chip/stm32/usb_dwc_hw.h @@ -0,0 +1,45 @@ +/* Copyright 2016 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef __CROS_EC_USB_DWC_HW_H +#define __CROS_EC_USB_DWC_HW_H + +#include "usb_dwc_registers.h" + +/* Helpers for endpoint declaration */ +#define _EP_HANDLER2(num, suffix) CONCAT3(ep_, num, suffix) +#define _EP_TX_HANDLER(num) _EP_HANDLER2(num, _tx) +#define _EP_RX_HANDLER(num) _EP_HANDLER2(num, _rx) +#define _EP_RESET_HANDLER(num) _EP_HANDLER2(num, _rst) + +#define USB_DECLARE_EP(num, tx_handler, rx_handler, rst_handler) \ + void _EP_TX_HANDLER(num)(void) \ + __attribute__ ((alias(STRINGIFY(tx_handler)))); \ + void _EP_RX_HANDLER(num)(void) \ + __attribute__ ((alias(STRINGIFY(rx_handler)))); \ + void _EP_RESET_HANDLER(num)(void) \ + __attribute__ ((alias(STRINGIFY(rst_handler)))) + +/* Endpoint callbacks */ +extern void (*usb_ep_tx[]) (void); +extern void (*usb_ep_rx[]) (void); +extern void (*usb_ep_reset[]) (void); +struct usb_setup_packet; +/* EP0 Interface handler callbacks */ +static int (*usb_iface_request[]) (struct usb_setup_packet *req); + +/* + * Declare any interface-specific control request handlers. These Setup packets + * arrive on the control endpoint (EP0), but are handled by the interface code. + * The callback must prepare the EP0 IN or OUT FIFOs and return the number of + * bytes placed in the IN FIFO. A negative return value will STALL the response + * (and thus indicate error to the host). + */ +#define _IFACE_HANDLER(num) CONCAT3(iface_, num, _request) +#define USB_DECLARE_IFACE(num, handler) \ + int _IFACE_HANDLER(num)(struct usb_setup_packet *req) \ + __attribute__ ((alias(STRINGIFY(handler)))) + +#endif /* __CROS_EC_USB_DWC_HW_H */ diff --git a/chip/stm32/usb_dwc_registers.h b/chip/stm32/usb_dwc_registers.h new file mode 100644 index 0000000000..0e29f6aad1 --- /dev/null +++ b/chip/stm32/usb_dwc_registers.h @@ -0,0 +1,7530 @@ +/* Copyright 2016 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + * + * Register map for STM32F446 USB + */ + +#ifndef __CHIP_STM32_USB_DWC_REGISTERS_H +#define __CHIP_STM32_USB_DWC_REGISTERS_H + +/* Endpoint state */ +struct dwc_usb_ep { + int max_packet; + int tx_fifo; + + int out_pending; + uint8_t *out_data; + uint8_t *out_databuffer; + int out_databuffer_max; + + int in_packets; + int in_pending; + uint8_t *in_data; + uint8_t *in_databuffer; + int in_databuffer_max; +}; + +/* USB state */ +enum dwc_usb_speed { + USB_SPEED_FS = 0, + USB_SPEED_HS, +}; + +enum dwc_usb_phy { + USB_PHY_INTERNAL = 0, + USB_PHY_ULPI, +}; + +struct dwc_usb { + struct dwc_usb_ep *ep[USB_EP_COUNT]; + enum dwc_usb_speed speed; + enum dwc_usb_phy phy_type; + int dma_en; + /* IRQ must be STM32_IRQ_OTG_FS / STM32_IRQ_OTG_HS */ + int irq; +}; + +extern struct dwc_usb_ep ep0_ctl; +extern struct dwc_usb usb_ctl; + +/* + * Added Alias Module Family Base Address to 0-instance Module Base Address + * Simplify GBASE(mname) macro + */ +#define GC_MODULE_OFFSET 0x10000 + +#define GBASE(mname) \ + GC_ ## mname ## _BASE_ADDR +#define GOFFSET(mname, rname) \ + GC_ ## mname ## _ ## rname ## _OFFSET + +#define GREG8(mname, rname) \ + REG8(GBASE(mname) + GOFFSET(mname, rname)) +#define GREG32(mname, rname) \ + REG32(GBASE(mname) + GOFFSET(mname, rname)) +#define GREG32_ADDR(mname, rname) \ + REG32_ADDR(GBASE(mname) + GOFFSET(mname, rname)) +#define GWRITE(mname, rname, value) (GREG32(mname, rname) = (value)) +#define GREAD(mname, rname) GREG32(mname, rname) + +#define GFIELD_MASK(mname, rname, fname) \ + GC_ ## mname ## _ ## rname ## _ ## fname ## _MASK + +#define GFIELD_LSB(mname, rname, fname) \ + GC_ ## mname ## _ ## rname ## _ ## fname ## _LSB + +#define GREAD_FIELD(mname, rname, fname) \ + ((GREG32(mname, rname) & GFIELD_MASK(mname, rname, fname)) \ + >> GFIELD_LSB(mname, rname, fname)) + +#define GWRITE_FIELD(mname, rname, fname, fval) \ + (GREG32(mname, rname) = \ + ((GREG32(mname, rname) & (~GFIELD_MASK(mname, rname, fname))) | \ + (((fval) << GFIELD_LSB(mname, rname, fname)) & \ + GFIELD_MASK(mname, rname, fname)))) + + +#define GBASE_I(mname, i) (GBASE(mname) + i*GC_MODULE_OFFSET) + +#define GREG32_I(mname, i, rname) \ + REG32(GBASE_I(mname, i) + GOFFSET(mname, rname)) + +#define GREG32_ADDR_I(mname, i, rname) \ + REG32_ADDR(GBASE_I(mname, i) + GOFFSET(mname, rname)) + +#define GWRITE_I(mname, i, rname, value) (GREG32_I(mname, i, rname) = (value)) +#define GREAD_I(mname, i, rname) GREG32_I(mname, i, rname) + +#define GREAD_FIELD_I(mname, i, rname, fname) \ + ((GREG32_I(mname, i, rname) & GFIELD_MASK(mname, rname, fname)) \ + >> GFIELD_LSB(mname, rname, fname)) + +#define GWRITE_FIELD_I(mname, i, rname, fname, fval) \ + (GREG32_I(mname, i, rname) = \ + ((GREG32_I(mname, i, rname) & (~GFIELD_MASK(mname, rname, fname))) | \ + (((fval) << GFIELD_LSB(mname, rname, fname)) & \ + GFIELD_MASK(mname, rname, fname)))) + +/* Replace masked bits with val << lsb */ +#define REG_WRITE_MLV(reg, mask, lsb, val) \ + (reg = ((reg & ~mask) | ((val << lsb) & mask))) + + +/* USB device controller */ +#define GR_USB_REG(off) REG32(GC_USB_BASE_ADDR + (off)) +#define GR_USB_GOTGCTL GR_USB_REG(GC_USB_GOTGCTL_OFFSET) +#define GR_USB_GOTGINT GR_USB_REG(GC_USB_GOTGINT_OFFSET) +#define GR_USB_GAHBCFG GR_USB_REG(GC_USB_GAHBCFG_OFFSET) +#define GR_USB_GUSBCFG GR_USB_REG(GC_USB_GUSBCFG_OFFSET) +#define GR_USB_GRSTCTL GR_USB_REG(GC_USB_GRSTCTL_OFFSET) +#define GR_USB_GINTSTS GR_USB_REG(GC_USB_GINTSTS_OFFSET) +#define GINTSTS(bit) (1 << GC_USB_GINTSTS_ ## bit ## _LSB) +#define GR_USB_GINTMSK GR_USB_REG(GC_USB_GINTMSK_OFFSET) +#define GINTMSK(bit) (1 << GC_USB_GINTMSK_ ## bit ## MSK_LSB) +#define GR_USB_GRXSTSR GR_USB_REG(GC_USB_GRXSTSR_OFFSET) +#define GR_USB_GRXSTSP GR_USB_REG(GC_USB_GRXSTSP_OFFSET) +#define GR_USB_GRXFSIZ GR_USB_REG(GC_USB_GRXFSIZ_OFFSET) +#define GR_USB_GNPTXFSIZ GR_USB_REG(GC_USB_GNPTXFSIZ_OFFSET) +/*#define GR_USB_GGPIO GR_USB_REG(GC_USB_GGPIO_OFFSET)*/ +#define GR_USB_GCCFG GR_USB_REG(GC_USB_GCCFG_OFFSET) +#define GCCFG_VBDEN (1 << 21) +#define GCCFG_PWRDWN (1 << 16) +#define GR_USB_PCGCCTL GR_USB_REG(GC_USB_PCGCCTL_OFFSET) + +#define GR_USB_GSNPSID GR_USB_REG(GC_USB_GSNPSID_OFFSET) +#define GR_USB_GHWCFG1 GR_USB_REG(GC_USB_GHWCFG1_OFFSET) +#define GR_USB_GHWCFG2 GR_USB_REG(GC_USB_GHWCFG2_OFFSET) +#define GR_USB_GHWCFG3 GR_USB_REG(GC_USB_GHWCFG3_OFFSET) +#define GR_USB_GHWCFG4 GR_USB_REG(GC_USB_GHWCFG4_OFFSET) +#define GR_USB_GDFIFOCFG GR_USB_REG(GC_USB_GDFIFOCFG_OFFSET) +#define GR_USB_DIEPTXF(n) \ + GR_USB_REG(GC_USB_DIEPTXF1_OFFSET - 4 + (n)*4) +#define GR_USB_DCFG GR_USB_REG(GC_USB_DCFG_OFFSET) +#define GR_USB_DCTL GR_USB_REG(GC_USB_DCTL_OFFSET) +#define GR_USB_DSTS GR_USB_REG(GC_USB_DSTS_OFFSET) +#define GR_USB_DIEPMSK GR_USB_REG(GC_USB_DIEPMSK_OFFSET) +#define GR_USB_DOEPMSK GR_USB_REG(GC_USB_DOEPMSK_OFFSET) +#define GR_USB_DAINT GR_USB_REG(GC_USB_DAINT_OFFSET) +#define GR_USB_DAINTMSK GR_USB_REG(GC_USB_DAINTMSK_OFFSET) +#define DAINT_INEP(ep) (1 << (ep + GC_USB_DAINTMSK_INEPMSK0_LSB)) +#define DAINT_OUTEP(ep) \ + (1 << (ep + GC_USB_DAINTMSK_OUTEPMSK0_LSB)) +#define GR_USB_DTHRCTL GR_USB_REG(GC_USB_DTHRCTL_OFFSET) +#define DTHRCTL_TXTHRLEN_6 (0x40 << 2) +#define DTHRCTL_RXTHRLEN_6 (0x40 << 17) +#define DTHRCTL_RXTHREN (1 << 16) +#define DTHRCTL_ISOTHREN (1 << 1) +#define DTHRCTL_NONISOTHREN (1 << 0) +#define GR_USB_DIEPEMPMSK GR_USB_REG(GC_USB_DIEPEMPMSK_OFFSET) + +#define GR_USB_EPIREG(off, n) GR_USB_REG(0x900 + (n) * 0x20 + (off)) +#define GR_USB_EPOREG(off, n) GR_USB_REG(0xb00 + (n) * 0x20 + (off)) +#define GR_USB_DIEPCTL(n) GR_USB_EPIREG(0x00, n) +#define GR_USB_DIEPINT(n) GR_USB_EPIREG(0x08, n) +#define GR_USB_DIEPTSIZ(n) GR_USB_EPIREG(0x10, n) +#define GR_USB_DIEPDMA(n) GR_USB_EPIREG(0x14, n) +#define GR_USB_DTXFSTS(n) GR_USB_EPIREG(0x18, n) +#define GR_USB_DIEPDMAB(n) GR_USB_EPIREG(0x1c, n) +#define GR_USB_DOEPCTL(n) GR_USB_EPOREG(0x00, n) +#define GR_USB_DOEPINT(n) GR_USB_EPOREG(0x08, n) +#define GR_USB_DOEPTSIZ(n) GR_USB_EPOREG(0x10, n) +#define GR_USB_DOEPDMA(n) GR_USB_EPOREG(0x14, n) +#define GR_USB_DOEPDMAB(n) GR_USB_EPOREG(0x1c, n) + +#define GOTGCTL_BVALOEN (1 << GC_USB_GOTGCTL_BVALIDOVEN_LSB) +#define GOTGCTL_BVALOVAL (1 << 7) + +/* Bit 5 */ +#define GAHBCFG_DMA_EN (1 << GC_USB_GAHBCFG_DMAEN_LSB) +/* Bit 1 */ +#define GAHBCFG_GLB_INTR_EN (1 << GC_USB_GAHBCFG_GLBLINTRMSK_LSB) +/* HS Burst Len */ +#define GAHBCFG_HBSTLEN_INCR4 (3 << GC_USB_GAHBCFG_HBSTLEN_LSB) +/* Bit 7 */ +#define GAHBCFG_NP_TXF_EMP_LVL (1 << GC_USB_GAHBCFG_NPTXFEMPLVL_LSB) +#define GAHBCFG_TXFELVL GAHBCFG_NP_TXF_EMP_LVL +#define GAHBCFG_PTXFELVL (1 << 8) + +#define GUSBCFG_TOUTCAL(n) (((n) << GC_USB_GUSBCFG_TOUTCAL_LSB) \ + & GC_USB_GUSBCFG_TOUTCAL_MASK) +#define GUSBCFG_USBTRDTIM(n) (((n) << GC_USB_GUSBCFG_USBTRDTIM_LSB) \ + & GC_USB_GUSBCFG_USBTRDTIM_MASK) +/* Force device mode */ +#define GUSBCFG_FDMOD (1 << GC_USB_GUSBCFG_FDMOD_LSB) +#define GUSBCFG_PHYSEL (1 << 6) +#define GUSBCFG_SRPCAP (1 << 8) +#define GUSBCFG_HNPCAP (1 << 9) +#define GUSBCFG_ULPIFSLS (1 << 17) +#define GUSBCFG_ULPIAR (1 << 18) +#define GUSBCFG_ULPICSM (1 << 19) +#define GUSBCFG_ULPIEVBUSD (1 << 20) +#define GUSBCFG_ULPIEVBUSI (1 << 21) +#define GUSBCFG_TSDPS (1 << 22) +#define GUSBCFG_PCCI (1 << 23) +#define GUSBCFG_PTCI (1 << 24) +#define GUSBCFG_ULPIIPD (1 << 25) +#define GUSBCFG_TSDPS (1 << 22) + + +#define GRSTCTL_CSFTRST (1 << GC_USB_GRSTCTL_CSFTRST_LSB) +#define GRSTCTL_AHBIDLE (1 << GC_USB_GRSTCTL_AHBIDLE_LSB) +#define GRSTCTL_TXFFLSH (1 << GC_USB_GRSTCTL_TXFFLSH_LSB) +#define GRSTCTL_RXFFLSH (1 << GC_USB_GRSTCTL_RXFFLSH_LSB) +#define GRSTCTL_TXFNUM(n) \ + (((n) << GC_USB_GRSTCTL_TXFNUM_LSB) & GC_USB_GRSTCTL_TXFNUM_MASK) + +#define DCFG_DEVSPD_HSULPI (0 << GC_USB_DCFG_DEVSPD_LSB) +#define DCFG_DEVSPD_FSULPI (1 << GC_USB_DCFG_DEVSPD_LSB) +#define DCFG_DEVSPD_FS48 (3 << GC_USB_DCFG_DEVSPD_LSB) +#define DCFG_DEVADDR(a) \ + (((a) << GC_USB_DCFG_DEVADDR_LSB) & GC_USB_DCFG_DEVADDR_MASK) +#define DCFG_NZLSOHSK (1 << GC_USB_DCFG_NZSTSOUTHSHK_LSB) + +#define DCTL_SFTDISCON (1 << GC_USB_DCTL_SFTDISCON_LSB) +#define DCTL_CGOUTNAK (1 << GC_USB_DCTL_CGOUTNAK_LSB) +#define DCTL_CGNPINNAK (1 << GC_USB_DCTL_CGNPINNAK_LSB) +#define DCTL_PWRONPRGDONE (1 << GC_USB_DCTL_PWRONPRGDONE_LSB) + +/* Device Endpoint Common IN Interrupt Mask bits */ +#define DIEPMSK_AHBERRMSK (1 << GC_USB_DIEPMSK_AHBERRMSK_LSB) +#define DIEPMSK_BNAININTRMSK (1 << GC_USB_DIEPMSK_BNAININTRMSK_LSB) +#define DIEPMSK_EPDISBLDMSK (1 << GC_USB_DIEPMSK_EPDISBLDMSK_LSB) +#define DIEPMSK_INEPNAKEFFMSK (1 << GC_USB_DIEPMSK_INEPNAKEFFMSK_LSB) +#define DIEPMSK_INTKNEPMISMSK (1 << GC_USB_DIEPMSK_INTKNEPMISMSK_LSB) +#define DIEPMSK_INTKNTXFEMPMSK (1 << GC_USB_DIEPMSK_INTKNTXFEMPMSK_LSB) +#define DIEPMSK_NAKMSK (1 << GC_USB_DIEPMSK_NAKMSK_LSB) +#define DIEPMSK_TIMEOUTMSK (1 << GC_USB_DIEPMSK_TIMEOUTMSK_LSB) +#define DIEPMSK_TXFIFOUNDRNMSK (1 << GC_USB_DIEPMSK_TXFIFOUNDRNMSK_LSB) +#define DIEPMSK_XFERCOMPLMSK (1 << GC_USB_DIEPMSK_XFERCOMPLMSK_LSB) + +/* Device Endpoint Common OUT Interrupt Mask bits */ +#define DOEPMSK_AHBERRMSK (1 << GC_USB_DOEPMSK_AHBERRMSK_LSB) +#define DOEPMSK_BBLEERRMSK (1 << GC_USB_DOEPMSK_BBLEERRMSK_LSB) +#define DOEPMSK_BNAOUTINTRMSK (1 << GC_USB_DOEPMSK_BNAOUTINTRMSK_LSB) +#define DOEPMSK_EPDISBLDMSK (1 << GC_USB_DOEPMSK_EPDISBLDMSK_LSB) +#define DOEPMSK_NAKMSK (1 << GC_USB_DOEPMSK_NAKMSK_LSB) +#define DOEPMSK_NYETMSK (1 << GC_USB_DOEPMSK_NYETMSK_LSB) +#define DOEPMSK_OUTPKTERRMSK (1 << GC_USB_DOEPMSK_OUTPKTERRMSK_LSB) +#define DOEPMSK_OUTTKNEPDISMSK (1 << GC_USB_DOEPMSK_OUTTKNEPDISMSK_LSB) +#define DOEPMSK_SETUPMSK (1 << GC_USB_DOEPMSK_SETUPMSK_LSB) +#define DOEPMSK_STSPHSERCVDMSK (1 << GC_USB_DOEPMSK_STSPHSERCVDMSK_LSB) +#define DOEPMSK_XFERCOMPLMSK (1 << GC_USB_DOEPMSK_XFERCOMPLMSK_LSB) + +/* Device Endpoint-n IN Interrupt Register bits */ +#define DIEPINT_AHBERR (1 << GC_USB_DIEPINT0_AHBERR_LSB) +#define DIEPINT_BBLEERR (1 << GC_USB_DIEPINT0_BBLEERR_LSB) +#define DIEPINT_BNAINTR (1 << GC_USB_DIEPINT0_BNAINTR_LSB) +#define DIEPINT_EPDISBLD (1 << GC_USB_DIEPINT0_EPDISBLD_LSB) +#define DIEPINT_INEPNAKEFF (1 << GC_USB_DIEPINT0_INEPNAKEFF_LSB) +#define DIEPINT_INTKNEPMIS (1 << GC_USB_DIEPINT0_INTKNEPMIS_LSB) +#define DIEPINT_INTKNTXFEMP (1 << GC_USB_DIEPINT0_INTKNTXFEMP_LSB) +#define DIEPINT_NAKINTRPT (1 << GC_USB_DIEPINT0_NAKINTRPT_LSB) +#define DIEPINT_NYETINTRPT (1 << GC_USB_DIEPINT0_NYETINTRPT_LSB) +#define DIEPINT_PKTDRPSTS (1 << GC_USB_DIEPINT0_PKTDRPSTS_LSB) +#define DIEPINT_TIMEOUT (1 << GC_USB_DIEPINT0_TIMEOUT_LSB) +#define DIEPINT_TXFEMP (1 << GC_USB_DIEPINT0_TXFEMP_LSB) +#define DIEPINT_TXFIFOUNDRN (1 << GC_USB_DIEPINT0_TXFIFOUNDRN_LSB) +#define DIEPINT_XFERCOMPL (1 << GC_USB_DIEPINT0_XFERCOMPL_LSB) + +/* Device Endpoint-n OUT Interrupt Register bits */ +#define DOEPINT_AHBERR (1 << GC_USB_DOEPINT0_AHBERR_LSB) +#define DOEPINT_BACK2BACKSETUP (1 << GC_USB_DOEPINT0_BACK2BACKSETUP_LSB) +#define DOEPINT_BBLEERR (1 << GC_USB_DOEPINT0_BBLEERR_LSB) +#define DOEPINT_BNAINTR (1 << GC_USB_DOEPINT0_BNAINTR_LSB) +#define DOEPINT_EPDISBLD (1 << GC_USB_DOEPINT0_EPDISBLD_LSB) +#define DOEPINT_NAKINTRPT (1 << GC_USB_DOEPINT0_NAKINTRPT_LSB) +#define DOEPINT_NYETINTRPT (1 << GC_USB_DOEPINT0_NYETINTRPT_LSB) +#define DOEPINT_OUTPKTERR (1 << GC_USB_DOEPINT0_OUTPKTERR_LSB) +#define DOEPINT_OUTTKNEPDIS (1 << GC_USB_DOEPINT0_OUTTKNEPDIS_LSB) +#define DOEPINT_PKTDRPSTS (1 << GC_USB_DOEPINT0_PKTDRPSTS_LSB) +#define DOEPINT_SETUP (1 << GC_USB_DOEPINT0_SETUP_LSB) +#define DOEPINT_STSPHSERCVD (1 << GC_USB_DOEPINT0_STSPHSERCVD_LSB) +#define DOEPINT_STUPPKTRCVD (1 << GC_USB_DOEPINT0_STUPPKTRCVD_LSB) +#define DOEPINT_XFERCOMPL (1 << GC_USB_DOEPINT0_XFERCOMPL_LSB) + +#define DXEPCTL_EPTYPE_CTRL (0 << GC_USB_DIEPCTL0_EPTYPE_LSB) +#define DXEPCTL_EPTYPE_ISO (1 << GC_USB_DIEPCTL0_EPTYPE_LSB) +#define DXEPCTL_EPTYPE_BULK (2 << GC_USB_DIEPCTL0_EPTYPE_LSB) +#define DXEPCTL_EPTYPE_INT (3 << GC_USB_DIEPCTL0_EPTYPE_LSB) +#define DXEPCTL_EPTYPE_MASK GC_USB_DIEPCTL0_EPTYPE_MASK +#define DXEPCTL_TXFNUM(n) ((n) << GC_USB_DIEPCTL1_TXFNUM_LSB) +#define DXEPCTL_STALL (1 << GC_USB_DIEPCTL0_STALL_LSB) +#define DXEPCTL_CNAK (1 << GC_USB_DIEPCTL0_CNAK_LSB) +#define DXEPCTL_DPID (1 << GC_USB_DIEPCTL0_DPID_LSB) +#define DXEPCTL_SNAK (1 << GC_USB_DIEPCTL0_SNAK_LSB) +#define DXEPCTL_NAKSTS (1 << GC_USB_DIEPCTL0_NAKSTS_LSB) +#define DXEPCTL_EPENA (1 << GC_USB_DIEPCTL0_EPENA_LSB) +#define DXEPCTL_EPDIS (1 << GC_USB_DIEPCTL0_EPDIS_LSB) +#define DXEPCTL_USBACTEP (1 << GC_USB_DIEPCTL0_USBACTEP_LSB) +#define DXEPCTL_MPS64 (0 << GC_USB_DIEPCTL0_MPS_LSB) +#define DXEPCTL_MPS(cnt) ((cnt) << GC_USB_DIEPCTL1_MPS_LSB) + +#define DXEPTSIZ_SUPCNT(n) ((n) << GC_USB_DOEPTSIZ0_SUPCNT_LSB) +#define DXEPTSIZ_PKTCNT(n) ((n) << GC_USB_DIEPTSIZ0_PKTCNT_LSB) +#define DXEPTSIZ_XFERSIZE(n) ((n) << GC_USB_DIEPTSIZ0_XFERSIZE_LSB) + +#define DOEPDMA_BS_HOST_RDY (0 << 30) +#define DOEPDMA_BS_DMA_BSY (1 << 30) +#define DOEPDMA_BS_DMA_DONE (2 << 30) +#define DOEPDMA_BS_HOST_BSY (3 << 30) +#define DOEPDMA_BS_MASK (3 << 30) +#define DOEPDMA_RXSTS_MASK (3 << 28) +#define DOEPDMA_LAST (1 << 27) +#define DOEPDMA_SP (1 << 26) +#define DOEPDMA_IOC (1 << 25) +#define DOEPDMA_SR (1 << 24) +#define DOEPDMA_MTRF (1 << 23) +#define DOEPDMA_NAK (1 << 16) +#define DOEPDMA_RXBYTES(n) (((n) & 0xFFFF) << 0) +#define DOEPDMA_RXBYTES_MASK (0xFFFF << 0) + +#define DIEPDMA_BS_HOST_RDY (0 << 30) +#define DIEPDMA_BS_DMA_BSY (1 << 30) +#define DIEPDMA_BS_DMA_DONE (2 << 30) +#define DIEPDMA_BS_HOST_BSY (3 << 30) +#define DIEPDMA_BS_MASK (3 << 30) +#define DIEPDMA_TXSTS_MASK (3 << 28) +#define DIEPDMA_LAST (1 << 27) +#define DIEPDMA_SP (1 << 26) +#define DIEPDMA_IOC (1 << 25) +#define DIEPDMA_TXBYTES(n) (((n) & 0xFFFF) << 0) +#define DIEPDMA_TXBYTES_MASK (0xFFFF << 0) + + + +/* Register defs referenced from DWC block in CR50. This is not a native + * ST block, so we'll use this modified regdefs list. + */ + +#define GC_USB_FS_BASE_ADDR 0x50000000 +#define GC_USB_HS_BASE_ADDR 0x40040000 +#ifdef CONFIG_USB_DWC_FS +#define GC_USB_BASE_ADDR GC_USB_FS_BASE_ADDR +#else +#define GC_USB_BASE_ADDR GC_USB_HS_BASE_ADDR +#endif + +#define GC_USB_GOTGCTL_OFFSET 0x0 +#define GC_USB_GOTGCTL_DEFAULT 0x0 +#define GC_USB_GOTGINT_OFFSET 0x4 +#define GC_USB_GOTGINT_DEFAULT 0x0 +#define GC_USB_GAHBCFG_OFFSET 0x8 +#define GC_USB_GAHBCFG_DEFAULT 0x0 +#define GC_USB_GUSBCFG_OFFSET 0xc +#define GC_USB_GUSBCFG_DEFAULT 0x0 +#define GC_USB_GRSTCTL_OFFSET 0x10 +#define GC_USB_GRSTCTL_DEFAULT 0x0 +#define GC_USB_GINTSTS_OFFSET 0x14 +#define GC_USB_GINTSTS_DEFAULT 0x0 +#define GC_USB_GINTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_DEFAULT 0x0 +#define GC_USB_GRXSTSR_OFFSET 0x1c +#define GC_USB_GRXSTSR_DEFAULT 0x0 +#define GC_USB_GRXSTSP_OFFSET 0x20 +#define GC_USB_GRXSTSP_DEFAULT 0x0 +#define GC_USB_GRXFSIZ_OFFSET 0x24 +#define GC_USB_GRXFSIZ_DEFAULT 0x0 +#define GC_USB_GNPTXFSIZ_OFFSET 0x28 +#define GC_USB_GNPTXFSIZ_DEFAULT 0x0 + +#define GC_USB_GCCFG_OFFSET 0x38 +#define GC_USB_GCCFG_DEFAULT 0x0 +#define GC_USB_GUID_OFFSET 0x3c +#define GC_USB_GUID_DEFAULT 0x0 +#define GC_USB_GSNPSID_OFFSET 0x40 +#define GC_USB_GSNPSID_DEFAULT 0x0 +#define GC_USB_GHWCFG1_OFFSET 0x44 +#define GC_USB_GHWCFG1_DEFAULT 0x0 +#define GC_USB_GHWCFG2_OFFSET 0x48 +#define GC_USB_GHWCFG2_DEFAULT 0x0 +#define GC_USB_GHWCFG3_OFFSET 0x4c +#define GC_USB_GHWCFG3_DEFAULT 0x0 +#define GC_USB_GHWCFG4_OFFSET 0x50 +#define GC_USB_GHWCFG4_DEFAULT 0x0 +#define GC_USB_GDFIFOCFG_OFFSET 0x5c +#define GC_USB_GDFIFOCFG_DEFAULT 0x0 +#define GC_USB_DIEPTXF1_OFFSET 0x104 +#define GC_USB_DIEPTXF1_DEFAULT 0x1000 +#define GC_USB_DIEPTXF2_OFFSET 0x108 +#define GC_USB_DIEPTXF2_DEFAULT 0x0 +#define GC_USB_DIEPTXF3_OFFSET 0x10c +#define GC_USB_DIEPTXF3_DEFAULT 0x0 +#define GC_USB_DIEPTXF4_OFFSET 0x110 +#define GC_USB_DIEPTXF4_DEFAULT 0x0 +#define GC_USB_DIEPTXF5_OFFSET 0x114 +#define GC_USB_DIEPTXF5_DEFAULT 0x0 +#define GC_USB_DIEPTXF6_OFFSET 0x118 +#define GC_USB_DIEPTXF6_DEFAULT 0x0 +#define GC_USB_DIEPTXF7_OFFSET 0x11c +#define GC_USB_DIEPTXF7_DEFAULT 0x0 +#define GC_USB_DIEPTXF8_OFFSET 0x120 +#define GC_USB_DIEPTXF8_DEFAULT 0x0 +#define GC_USB_DIEPTXF9_OFFSET 0x124 +#define GC_USB_DIEPTXF9_DEFAULT 0x0 +#define GC_USB_DIEPTXF10_OFFSET 0x128 +#define GC_USB_DIEPTXF10_DEFAULT 0x0 +#define GC_USB_DIEPTXF11_OFFSET 0x12c +#define GC_USB_DIEPTXF11_DEFAULT 0x0 +#define GC_USB_DIEPTXF12_OFFSET 0x130 +#define GC_USB_DIEPTXF12_DEFAULT 0x0 +#define GC_USB_DIEPTXF13_OFFSET 0x134 +#define GC_USB_DIEPTXF13_DEFAULT 0x0 +#define GC_USB_DIEPTXF14_OFFSET 0x138 +#define GC_USB_DIEPTXF14_DEFAULT 0x0 +#define GC_USB_DIEPTXF15_OFFSET 0x13c +#define GC_USB_DIEPTXF15_DEFAULT 0x0 +#define GC_USB_DCFG_OFFSET 0x800 +#define GC_USB_DCFG_DEFAULT 0x8000000 +#define GC_USB_DCTL_OFFSET 0x804 +#define GC_USB_DCTL_DEFAULT 0x0 +#define GC_USB_DSTS_OFFSET 0x808 +#define GC_USB_DSTS_DEFAULT 0x0 +#define GC_USB_DIEPMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_DEFAULT 0x80 +#define GC_USB_DOEPMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_DEFAULT 0x0 +#define GC_USB_DAINT_OFFSET 0x818 +#define GC_USB_DAINT_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OFFSET 0x81c +#define GC_USB_DAINTMSK_DEFAULT 0x0 +#define GC_USB_DVBUSDIS_OFFSET 0x828 +#define GC_USB_DVBUSDIS_DEFAULT 0x0 +#define GC_USB_DVBUSPULSE_OFFSET 0x82c +#define GC_USB_DVBUSPULSE_DEFAULT 0x0 +#define GC_USB_DTHRCTL_OFFSET 0x830 +#define GC_USB_DTHRCTL_DEFAULT 0x0 +#define GC_USB_DIEPEMPMSK_OFFSET 0x834 +#define GC_USB_DIEPEMPMSK_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_OFFSET 0x900 +#define GC_USB_DIEPCTL0_DEFAULT 0x0 +#define GC_USB_DIEPINT0_OFFSET 0x908 +#define GC_USB_DIEPINT0_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ0_OFFSET 0x910 +#define GC_USB_DIEPTSIZ0_DEFAULT 0x0 +#define GC_USB_DIEPDMA0_OFFSET 0x914 +#define GC_USB_DIEPDMA0_DEFAULT 0x0 +#define GC_USB_DTXFSTS0_OFFSET 0x918 +#define GC_USB_DTXFSTS0_DEFAULT 0x0 +#define GC_USB_DIEPDMAB0_OFFSET 0x91c +#define GC_USB_DIEPDMAB0_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_OFFSET 0x920 +#define GC_USB_DIEPCTL1_DEFAULT 0x0 +#define GC_USB_DIEPINT1_OFFSET 0x928 +#define GC_USB_DIEPINT1_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ1_OFFSET 0x930 +#define GC_USB_DIEPTSIZ1_DEFAULT 0x0 +#define GC_USB_DIEPDMA1_OFFSET 0x934 +#define GC_USB_DIEPDMA1_DEFAULT 0x0 +#define GC_USB_DTXFSTS1_OFFSET 0x938 +#define GC_USB_DTXFSTS1_DEFAULT 0x0 +#define GC_USB_DIEPDMAB1_OFFSET 0x93c +#define GC_USB_DIEPDMAB1_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_OFFSET 0x940 +#define GC_USB_DIEPCTL2_DEFAULT 0x0 +#define GC_USB_DIEPINT2_OFFSET 0x948 +#define GC_USB_DIEPINT2_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ2_OFFSET 0x950 +#define GC_USB_DIEPTSIZ2_DEFAULT 0x0 +#define GC_USB_DIEPDMA2_OFFSET 0x954 +#define GC_USB_DIEPDMA2_DEFAULT 0x0 +#define GC_USB_DTXFSTS2_OFFSET 0x958 +#define GC_USB_DTXFSTS2_DEFAULT 0x0 +#define GC_USB_DIEPDMAB2_OFFSET 0x95c +#define GC_USB_DIEPDMAB2_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_OFFSET 0x960 +#define GC_USB_DIEPCTL3_DEFAULT 0x0 +#define GC_USB_DIEPINT3_OFFSET 0x968 +#define GC_USB_DIEPINT3_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ3_OFFSET 0x970 +#define GC_USB_DIEPTSIZ3_DEFAULT 0x0 +#define GC_USB_DIEPDMA3_OFFSET 0x974 +#define GC_USB_DIEPDMA3_DEFAULT 0x0 +#define GC_USB_DTXFSTS3_OFFSET 0x978 +#define GC_USB_DTXFSTS3_DEFAULT 0x0 +#define GC_USB_DIEPDMAB3_OFFSET 0x97c +#define GC_USB_DIEPDMAB3_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_OFFSET 0x980 +#define GC_USB_DIEPCTL4_DEFAULT 0x0 +#define GC_USB_DIEPINT4_OFFSET 0x988 +#define GC_USB_DIEPINT4_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ4_OFFSET 0x990 +#define GC_USB_DIEPTSIZ4_DEFAULT 0x0 +#define GC_USB_DIEPDMA4_OFFSET 0x994 +#define GC_USB_DIEPDMA4_DEFAULT 0x0 +#define GC_USB_DTXFSTS4_OFFSET 0x998 +#define GC_USB_DTXFSTS4_DEFAULT 0x0 +#define GC_USB_DIEPDMAB4_OFFSET 0x99c +#define GC_USB_DIEPDMAB4_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_DEFAULT 0x0 +#define GC_USB_DIEPINT5_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ5_OFFSET 0x9b0 +#define GC_USB_DIEPTSIZ5_DEFAULT 0x0 +#define GC_USB_DIEPDMA5_OFFSET 0x9b4 +#define GC_USB_DIEPDMA5_DEFAULT 0x0 +#define GC_USB_DTXFSTS5_OFFSET 0x9b8 +#define GC_USB_DTXFSTS5_DEFAULT 0x0 +#define GC_USB_DIEPDMAB5_OFFSET 0x9bc +#define GC_USB_DIEPDMAB5_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_DEFAULT 0x0 +#define GC_USB_DIEPINT6_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ6_OFFSET 0x9d0 +#define GC_USB_DIEPTSIZ6_DEFAULT 0x0 +#define GC_USB_DIEPDMA6_OFFSET 0x9d4 +#define GC_USB_DIEPDMA6_DEFAULT 0x0 +#define GC_USB_DTXFSTS6_OFFSET 0x9d8 +#define GC_USB_DTXFSTS6_DEFAULT 0x0 +#define GC_USB_DIEPDMAB6_OFFSET 0x9dc +#define GC_USB_DIEPDMAB6_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_DEFAULT 0x0 +#define GC_USB_DIEPINT7_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ7_OFFSET 0x9f0 +#define GC_USB_DIEPTSIZ7_DEFAULT 0x0 +#define GC_USB_DIEPDMA7_OFFSET 0x9f4 +#define GC_USB_DIEPDMA7_DEFAULT 0x0 +#define GC_USB_DTXFSTS7_OFFSET 0x9f8 +#define GC_USB_DTXFSTS7_DEFAULT 0x0 +#define GC_USB_DIEPDMAB7_OFFSET 0x9fc +#define GC_USB_DIEPDMAB7_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_DEFAULT 0x0 +#define GC_USB_DIEPINT8_OFFSET 0xa08 +#define GC_USB_DIEPINT8_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ8_OFFSET 0xa10 +#define GC_USB_DIEPTSIZ8_DEFAULT 0x0 +#define GC_USB_DIEPDMA8_OFFSET 0xa14 +#define GC_USB_DIEPDMA8_DEFAULT 0x0 +#define GC_USB_DTXFSTS8_OFFSET 0xa18 +#define GC_USB_DTXFSTS8_DEFAULT 0x0 +#define GC_USB_DIEPDMAB8_OFFSET 0xa1c +#define GC_USB_DIEPDMAB8_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_DEFAULT 0x0 +#define GC_USB_DIEPINT9_OFFSET 0xa28 +#define GC_USB_DIEPINT9_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ9_OFFSET 0xa30 +#define GC_USB_DIEPTSIZ9_DEFAULT 0x0 +#define GC_USB_DIEPDMA9_OFFSET 0xa34 +#define GC_USB_DIEPDMA9_DEFAULT 0x0 +#define GC_USB_DTXFSTS9_OFFSET 0xa38 +#define GC_USB_DTXFSTS9_DEFAULT 0x0 +#define GC_USB_DIEPDMAB9_OFFSET 0xa3c +#define GC_USB_DIEPDMAB9_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_DEFAULT 0x0 +#define GC_USB_DIEPINT10_OFFSET 0xa48 +#define GC_USB_DIEPINT10_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ10_OFFSET 0xa50 +#define GC_USB_DIEPTSIZ10_DEFAULT 0x0 +#define GC_USB_DIEPDMA10_OFFSET 0xa54 +#define GC_USB_DIEPDMA10_DEFAULT 0x0 +#define GC_USB_DTXFSTS10_OFFSET 0xa58 +#define GC_USB_DTXFSTS10_DEFAULT 0x0 +#define GC_USB_DIEPDMAB10_OFFSET 0xa5c +#define GC_USB_DIEPDMAB10_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_DEFAULT 0x0 +#define GC_USB_DIEPINT11_OFFSET 0xa68 +#define GC_USB_DIEPINT11_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ11_OFFSET 0xa70 +#define GC_USB_DIEPTSIZ11_DEFAULT 0x0 +#define GC_USB_DIEPDMA11_OFFSET 0xa74 +#define GC_USB_DIEPDMA11_DEFAULT 0x0 +#define GC_USB_DTXFSTS11_OFFSET 0xa78 +#define GC_USB_DTXFSTS11_DEFAULT 0x0 +#define GC_USB_DIEPDMAB11_OFFSET 0xa7c +#define GC_USB_DIEPDMAB11_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_DEFAULT 0x0 +#define GC_USB_DIEPINT12_OFFSET 0xa88 +#define GC_USB_DIEPINT12_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ12_OFFSET 0xa90 +#define GC_USB_DIEPTSIZ12_DEFAULT 0x0 +#define GC_USB_DIEPDMA12_OFFSET 0xa94 +#define GC_USB_DIEPDMA12_DEFAULT 0x0 +#define GC_USB_DTXFSTS12_OFFSET 0xa98 +#define GC_USB_DTXFSTS12_DEFAULT 0x0 +#define GC_USB_DIEPDMAB12_OFFSET 0xa9c +#define GC_USB_DIEPDMAB12_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_DEFAULT 0x0 +#define GC_USB_DIEPINT13_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ13_OFFSET 0xab0 +#define GC_USB_DIEPTSIZ13_DEFAULT 0x0 +#define GC_USB_DIEPDMA13_OFFSET 0xab4 +#define GC_USB_DIEPDMA13_DEFAULT 0x0 +#define GC_USB_DTXFSTS13_OFFSET 0xab8 +#define GC_USB_DTXFSTS13_DEFAULT 0x0 +#define GC_USB_DIEPDMAB13_OFFSET 0xabc +#define GC_USB_DIEPDMAB13_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_DEFAULT 0x0 +#define GC_USB_DIEPINT14_OFFSET 0xac8 +#define GC_USB_DIEPINT14_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ14_OFFSET 0xad0 +#define GC_USB_DIEPTSIZ14_DEFAULT 0x0 +#define GC_USB_DIEPDMA14_OFFSET 0xad4 +#define GC_USB_DIEPDMA14_DEFAULT 0x0 +#define GC_USB_DTXFSTS14_OFFSET 0xad8 +#define GC_USB_DTXFSTS14_DEFAULT 0x0 +#define GC_USB_DIEPDMAB14_OFFSET 0xadc +#define GC_USB_DIEPDMAB14_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_DEFAULT 0x0 +#define GC_USB_DIEPINT15_OFFSET 0xae8 +#define GC_USB_DIEPINT15_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ15_OFFSET 0xaf0 +#define GC_USB_DIEPTSIZ15_DEFAULT 0x0 +#define GC_USB_DIEPDMA15_OFFSET 0xaf4 +#define GC_USB_DIEPDMA15_DEFAULT 0x0 +#define GC_USB_DTXFSTS15_OFFSET 0xaf8 +#define GC_USB_DTXFSTS15_DEFAULT 0x0 +#define GC_USB_DIEPDMAB15_OFFSET 0xafc +#define GC_USB_DIEPDMAB15_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_DEFAULT 0x0 +#define GC_USB_DOEPINT0_OFFSET 0xb08 +#define GC_USB_DOEPINT0_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ0_OFFSET 0xb10 +#define GC_USB_DOEPTSIZ0_DEFAULT 0x0 +#define GC_USB_DOEPDMA0_OFFSET 0xb14 +#define GC_USB_DOEPDMA0_DEFAULT 0x0 +#define GC_USB_DOEPDMAB0_OFFSET 0xb1c +#define GC_USB_DOEPDMAB0_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_DEFAULT 0x0 +#define GC_USB_DOEPINT1_OFFSET 0xb28 +#define GC_USB_DOEPINT1_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ1_OFFSET 0xb30 +#define GC_USB_DOEPTSIZ1_DEFAULT 0x0 +#define GC_USB_DOEPDMA1_OFFSET 0xb34 +#define GC_USB_DOEPDMA1_DEFAULT 0x0 +#define GC_USB_DOEPDMAB1_OFFSET 0xb3c +#define GC_USB_DOEPDMAB1_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_DEFAULT 0x0 +#define GC_USB_DOEPINT2_OFFSET 0xb48 +#define GC_USB_DOEPINT2_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ2_OFFSET 0xb50 +#define GC_USB_DOEPTSIZ2_DEFAULT 0x0 +#define GC_USB_DOEPDMA2_OFFSET 0xb54 +#define GC_USB_DOEPDMA2_DEFAULT 0x0 +#define GC_USB_DOEPDMAB2_OFFSET 0xb5c +#define GC_USB_DOEPDMAB2_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_DEFAULT 0x0 +#define GC_USB_DOEPINT3_OFFSET 0xb68 +#define GC_USB_DOEPINT3_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ3_OFFSET 0xb70 +#define GC_USB_DOEPTSIZ3_DEFAULT 0x0 +#define GC_USB_DOEPDMA3_OFFSET 0xb74 +#define GC_USB_DOEPDMA3_DEFAULT 0x0 +#define GC_USB_DOEPDMAB3_OFFSET 0xb7c +#define GC_USB_DOEPDMAB3_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_DEFAULT 0x0 +#define GC_USB_DOEPINT4_OFFSET 0xb88 +#define GC_USB_DOEPINT4_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ4_OFFSET 0xb90 +#define GC_USB_DOEPTSIZ4_DEFAULT 0x0 +#define GC_USB_DOEPDMA4_OFFSET 0xb94 +#define GC_USB_DOEPDMA4_DEFAULT 0x0 +#define GC_USB_DOEPDMAB4_OFFSET 0xb9c +#define GC_USB_DOEPDMAB4_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_DEFAULT 0x0 +#define GC_USB_DOEPINT5_OFFSET 0xba8 +#define GC_USB_DOEPINT5_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ5_OFFSET 0xbb0 +#define GC_USB_DOEPTSIZ5_DEFAULT 0x0 +#define GC_USB_DOEPDMA5_OFFSET 0xbb4 +#define GC_USB_DOEPDMA5_DEFAULT 0x0 +#define GC_USB_DOEPDMAB5_OFFSET 0xbbc +#define GC_USB_DOEPDMAB5_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_DEFAULT 0x0 +#define GC_USB_DOEPINT6_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ6_OFFSET 0xbd0 +#define GC_USB_DOEPTSIZ6_DEFAULT 0x0 +#define GC_USB_DOEPDMA6_OFFSET 0xbd4 +#define GC_USB_DOEPDMA6_DEFAULT 0x0 +#define GC_USB_DOEPDMAB6_OFFSET 0xbdc +#define GC_USB_DOEPDMAB6_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_DEFAULT 0x0 +#define GC_USB_DOEPINT7_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ7_OFFSET 0xbf0 +#define GC_USB_DOEPTSIZ7_DEFAULT 0x0 +#define GC_USB_DOEPDMA7_OFFSET 0xbf4 +#define GC_USB_DOEPDMA7_DEFAULT 0x0 +#define GC_USB_DOEPDMAB7_OFFSET 0xbfc +#define GC_USB_DOEPDMAB7_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_DEFAULT 0x0 +#define GC_USB_DOEPINT8_OFFSET 0xc08 +#define GC_USB_DOEPINT8_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ8_OFFSET 0xc10 +#define GC_USB_DOEPTSIZ8_DEFAULT 0x0 +#define GC_USB_DOEPDMA8_OFFSET 0xc14 +#define GC_USB_DOEPDMA8_DEFAULT 0x0 +#define GC_USB_DOEPDMAB8_OFFSET 0xc1c +#define GC_USB_DOEPDMAB8_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_DEFAULT 0x0 +#define GC_USB_DOEPINT9_OFFSET 0xc28 +#define GC_USB_DOEPINT9_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ9_OFFSET 0xc30 +#define GC_USB_DOEPTSIZ9_DEFAULT 0x0 +#define GC_USB_DOEPDMA9_OFFSET 0xc34 +#define GC_USB_DOEPDMA9_DEFAULT 0x0 +#define GC_USB_DOEPDMAB9_OFFSET 0xc3c +#define GC_USB_DOEPDMAB9_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_DEFAULT 0x0 +#define GC_USB_DOEPINT10_OFFSET 0xc48 +#define GC_USB_DOEPINT10_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ10_OFFSET 0xc50 +#define GC_USB_DOEPTSIZ10_DEFAULT 0x0 +#define GC_USB_DOEPDMA10_OFFSET 0xc54 +#define GC_USB_DOEPDMA10_DEFAULT 0x0 +#define GC_USB_DOEPDMAB10_OFFSET 0xc5c +#define GC_USB_DOEPDMAB10_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_DEFAULT 0x0 +#define GC_USB_DOEPINT11_OFFSET 0xc68 +#define GC_USB_DOEPINT11_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ11_OFFSET 0xc70 +#define GC_USB_DOEPTSIZ11_DEFAULT 0x0 +#define GC_USB_DOEPDMA11_OFFSET 0xc74 +#define GC_USB_DOEPDMA11_DEFAULT 0x0 +#define GC_USB_DOEPDMAB11_OFFSET 0xc7c +#define GC_USB_DOEPDMAB11_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_DEFAULT 0x0 +#define GC_USB_DOEPINT12_OFFSET 0xc88 +#define GC_USB_DOEPINT12_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ12_OFFSET 0xc90 +#define GC_USB_DOEPTSIZ12_DEFAULT 0x0 +#define GC_USB_DOEPDMA12_OFFSET 0xc94 +#define GC_USB_DOEPDMA12_DEFAULT 0x0 +#define GC_USB_DOEPDMAB12_OFFSET 0xc9c +#define GC_USB_DOEPDMAB12_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_DEFAULT 0x0 +#define GC_USB_DOEPINT13_OFFSET 0xca8 +#define GC_USB_DOEPINT13_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ13_OFFSET 0xcb0 +#define GC_USB_DOEPTSIZ13_DEFAULT 0x0 +#define GC_USB_DOEPDMA13_OFFSET 0xcb4 +#define GC_USB_DOEPDMA13_DEFAULT 0x0 +#define GC_USB_DOEPDMAB13_OFFSET 0xcbc +#define GC_USB_DOEPDMAB13_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_DEFAULT 0x0 +#define GC_USB_DOEPINT14_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ14_OFFSET 0xcd0 +#define GC_USB_DOEPTSIZ14_DEFAULT 0x0 +#define GC_USB_DOEPDMA14_OFFSET 0xcd4 +#define GC_USB_DOEPDMA14_DEFAULT 0x0 +#define GC_USB_DOEPDMAB14_OFFSET 0xcdc +#define GC_USB_DOEPDMAB14_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_DEFAULT 0x0 +#define GC_USB_DOEPINT15_OFFSET 0xce8 +#define GC_USB_DOEPINT15_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ15_OFFSET 0xcf0 +#define GC_USB_DOEPTSIZ15_DEFAULT 0x0 +#define GC_USB_DOEPDMA15_OFFSET 0xcf4 +#define GC_USB_DOEPDMA15_DEFAULT 0x0 +#define GC_USB_DOEPDMAB15_OFFSET 0xcfc +#define GC_USB_DOEPDMAB15_DEFAULT 0x0 +#define GC_USB_PCGCCTL_OFFSET 0xe00 +#define GC_USB_PCGCCTL_DEFAULT 0x0 +#define GC_USB_DFIFO_OFFSET 0x20000 +#define GC_USB_GOTGCTL_BVALIDOVEN_LSB 0x6 +#define GC_USB_GOTGCTL_BVALIDOVEN_MASK 0x40 +#define GC_USB_GOTGCTL_BVALIDOVEN_SIZE 0x1 +#define GC_USB_GOTGCTL_BVALIDOVEN_DEFAULT 0x0 +#define GC_USB_GOTGCTL_BVALIDOVEN_OFFSET 0x0 +#define GC_USB_GOTGCTL_BVALIDOVVAL_LSB 0x7 +#define GC_USB_GOTGCTL_BVALIDOVVAL_MASK 0x80 +#define GC_USB_GOTGCTL_BVALIDOVVAL_SIZE 0x1 +#define GC_USB_GOTGCTL_BVALIDOVVAL_DEFAULT 0x0 +#define GC_USB_GOTGCTL_BVALIDOVVAL_OFFSET 0x0 +#define GC_USB_GOTGCTL_CONIDSTS_LSB 0x10 +#define GC_USB_GOTGCTL_CONIDSTS_MASK 0x10000 +#define GC_USB_GOTGCTL_CONIDSTS_SIZE 0x1 +#define GC_USB_GOTGCTL_CONIDSTS_DEFAULT 0x0 +#define GC_USB_GOTGCTL_CONIDSTS_OFFSET 0x0 +#define GC_USB_GOTGCTL_BSESVLD_LSB 0x13 +#define GC_USB_GOTGCTL_BSESVLD_MASK 0x80000 +#define GC_USB_GOTGCTL_BSESVLD_SIZE 0x1 +#define GC_USB_GOTGCTL_BSESVLD_DEFAULT 0x0 +#define GC_USB_GOTGCTL_BSESVLD_OFFSET 0x0 +#define GC_USB_GOTGCTL_OTGVER_LSB 0x14 +#define GC_USB_GOTGCTL_OTGVER_MASK 0x100000 +#define GC_USB_GOTGCTL_OTGVER_SIZE 0x1 +#define GC_USB_GOTGCTL_OTGVER_DEFAULT 0x0 +#define GC_USB_GOTGCTL_OTGVER_OFFSET 0x0 +#define GC_USB_GOTGCTL_CURMOD_LSB 0x15 +#define GC_USB_GOTGCTL_CURMOD_MASK 0x200000 +#define GC_USB_GOTGCTL_CURMOD_SIZE 0x1 +#define GC_USB_GOTGCTL_CURMOD_DEFAULT 0x0 +#define GC_USB_GOTGCTL_CURMOD_OFFSET 0x0 +#define GC_USB_GOTGINT_SESENDDET_LSB 0x2 +#define GC_USB_GOTGINT_SESENDDET_MASK 0x4 +#define GC_USB_GOTGINT_SESENDDET_SIZE 0x1 +#define GC_USB_GOTGINT_SESENDDET_DEFAULT 0x0 +#define GC_USB_GOTGINT_SESENDDET_OFFSET 0x4 +#define GC_USB_GOTGINT_SESREQSUCSTSCHNG_LSB 0x8 +#define GC_USB_GOTGINT_SESREQSUCSTSCHNG_MASK 0x100 +#define GC_USB_GOTGINT_SESREQSUCSTSCHNG_SIZE 0x1 +#define GC_USB_GOTGINT_SESREQSUCSTSCHNG_DEFAULT 0x0 +#define GC_USB_GOTGINT_SESREQSUCSTSCHNG_OFFSET 0x4 +#define GC_USB_GOTGINT_HSTNEGSUCSTSCHNG_LSB 0x9 +#define GC_USB_GOTGINT_HSTNEGSUCSTSCHNG_MASK 0x200 +#define GC_USB_GOTGINT_HSTNEGSUCSTSCHNG_SIZE 0x1 +#define GC_USB_GOTGINT_HSTNEGSUCSTSCHNG_DEFAULT 0x0 +#define GC_USB_GOTGINT_HSTNEGSUCSTSCHNG_OFFSET 0x4 +#define GC_USB_GOTGINT_HSTNEGDET_LSB 0x11 +#define GC_USB_GOTGINT_HSTNEGDET_MASK 0x20000 +#define GC_USB_GOTGINT_HSTNEGDET_SIZE 0x1 +#define GC_USB_GOTGINT_HSTNEGDET_DEFAULT 0x0 +#define GC_USB_GOTGINT_HSTNEGDET_OFFSET 0x4 +#define GC_USB_GOTGINT_ADEVTOUTCHG_LSB 0x12 +#define GC_USB_GOTGINT_ADEVTOUTCHG_MASK 0x40000 +#define GC_USB_GOTGINT_ADEVTOUTCHG_SIZE 0x1 +#define GC_USB_GOTGINT_ADEVTOUTCHG_DEFAULT 0x0 +#define GC_USB_GOTGINT_ADEVTOUTCHG_OFFSET 0x4 +#define GC_USB_GAHBCFG_GLBLINTRMSK_LSB 0x0 +#define GC_USB_GAHBCFG_GLBLINTRMSK_MASK 0x1 +#define GC_USB_GAHBCFG_GLBLINTRMSK_SIZE 0x1 +#define GC_USB_GAHBCFG_GLBLINTRMSK_DEFAULT 0x0 +#define GC_USB_GAHBCFG_GLBLINTRMSK_OFFSET 0x8 +#define GC_USB_GAHBCFG_HBSTLEN_LSB 0x1 +#define GC_USB_GAHBCFG_HBSTLEN_MASK 0x1e +#define GC_USB_GAHBCFG_HBSTLEN_SIZE 0x4 +#define GC_USB_GAHBCFG_HBSTLEN_DEFAULT 0x0 +#define GC_USB_GAHBCFG_HBSTLEN_OFFSET 0x8 +#define GC_USB_GAHBCFG_DMAEN_LSB 0x5 +#define GC_USB_GAHBCFG_DMAEN_MASK 0x20 +#define GC_USB_GAHBCFG_DMAEN_SIZE 0x1 +#define GC_USB_GAHBCFG_DMAEN_DEFAULT 0x0 +#define GC_USB_GAHBCFG_DMAEN_OFFSET 0x8 + +#define GC_USB_GAHBCFG_NPTXFEMPLVL_LSB 0x7 +#define GC_USB_GAHBCFG_NPTXFEMPLVL_MASK 0x80 +#define GC_USB_GAHBCFG_NPTXFEMPLVL_SIZE 0x1 +#define GC_USB_GAHBCFG_NPTXFEMPLVL_DEFAULT 0x0 +#define GC_USB_GAHBCFG_NPTXFEMPLVL_OFFSET 0x8 + +#define GC_USB_GAHBCFG_REMMEMSUPP_LSB 0x15 +#define GC_USB_GAHBCFG_REMMEMSUPP_MASK 0x200000 +#define GC_USB_GAHBCFG_REMMEMSUPP_SIZE 0x1 +#define GC_USB_GAHBCFG_REMMEMSUPP_DEFAULT 0x0 +#define GC_USB_GAHBCFG_REMMEMSUPP_OFFSET 0x8 +#define GC_USB_GAHBCFG_NOTIALLDMAWRIT_LSB 0x16 +#define GC_USB_GAHBCFG_NOTIALLDMAWRIT_MASK 0x400000 +#define GC_USB_GAHBCFG_NOTIALLDMAWRIT_SIZE 0x1 +#define GC_USB_GAHBCFG_NOTIALLDMAWRIT_DEFAULT 0x0 +#define GC_USB_GAHBCFG_NOTIALLDMAWRIT_OFFSET 0x8 +#define GC_USB_GAHBCFG_AHBSINGLE_LSB 0x17 +#define GC_USB_GAHBCFG_AHBSINGLE_MASK 0x800000 +#define GC_USB_GAHBCFG_AHBSINGLE_SIZE 0x1 +#define GC_USB_GAHBCFG_AHBSINGLE_DEFAULT 0x0 +#define GC_USB_GAHBCFG_AHBSINGLE_OFFSET 0x8 +#define GC_USB_GAHBCFG_INVDESCENDIANESS_LSB 0x18 +#define GC_USB_GAHBCFG_INVDESCENDIANESS_MASK 0x1000000 +#define GC_USB_GAHBCFG_INVDESCENDIANESS_SIZE 0x1 +#define GC_USB_GAHBCFG_INVDESCENDIANESS_DEFAULT 0x0 +#define GC_USB_GAHBCFG_INVDESCENDIANESS_OFFSET 0x8 +#define GC_USB_GUSBCFG_TOUTCAL_LSB 0x0 +#define GC_USB_GUSBCFG_TOUTCAL_MASK 0x7 +#define GC_USB_GUSBCFG_TOUTCAL_SIZE 0x3 +#define GC_USB_GUSBCFG_TOUTCAL_DEFAULT 0x0 +#define GC_USB_GUSBCFG_TOUTCAL_OFFSET 0xc + +#define GC_USB_GUSBCFG_USBTRDTIM_LSB 0xa +#define GC_USB_GUSBCFG_USBTRDTIM_MASK 0x3c00 +#define GC_USB_GUSBCFG_USBTRDTIM_SIZE 0x4 +#define GC_USB_GUSBCFG_USBTRDTIM_DEFAULT 0x0 +#define GC_USB_GUSBCFG_USBTRDTIM_OFFSET 0xc +#define GC_USB_GUSBCFG_PHYLPWRCLKSEL_LSB 15 +#define GC_USB_GUSBCFG_PHYLPWRCLKSEL_MASK 0x8000 +#define GC_USB_GUSBCFG_PHYLPWRCLKSEL_SIZE 0x1 +#define GC_USB_GUSBCFG_PHYLPWRCLKSEL_DEFAULT 0x0 +#define GC_USB_GUSBCFG_PHYLPWRCLKSEL_OFFSET 0xc +#define GC_USB_GUSBCFG_ULPIFSLS_LSB 17 +#define GC_USB_GUSBCFG_ULPIFSLS_MASK 0x20000 +#define GC_USB_GUSBCFG_ULPIFSLS_SIZE 0x1 +#define GC_USB_GUSBCFG_ULPIFSLS_DEFAULT 0x0 +#define GC_USB_GUSBCFG_ULPIFSLS_OFFSET 0xc +#define GC_USB_GUSBCFG_ULPIAUTORES_LSB 18 +#define GC_USB_GUSBCFG_ULPIAUTORES_MASK 0x40000 +#define GC_USB_GUSBCFG_ULPIAUTORES_SIZE 0x1 +#define GC_USB_GUSBCFG_ULPIAUTORES_DEFAULT 0x0 +#define GC_USB_GUSBCFG_ULPIAUTORES_OFFSET 0xc +#define GC_USB_GUSBCFG_ULPICLKSUSM_LSB 19 +#define GC_USB_GUSBCFG_ULPICLKSUSM_MASK 0x80000 +#define GC_USB_GUSBCFG_ULPICLKSUSM_SIZE 0x1 +#define GC_USB_GUSBCFG_ULPICLKSUSM_DEFAULT 0x0 +#define GC_USB_GUSBCFG_ULPICLKSUSM_OFFSET 0xc + +#define GC_USB_GUSBCFG_ULPIEVBUSD_LSB 20 +#define GC_USB_GUSBCFG_ULPIEVBUSD_MASK 0x100000 +#define GC_USB_GUSBCFG_ULPIEVBUSD_SIZE 0x1 +#define GC_USB_GUSBCFG_ULPIEVBUSD_DEFAULT 0x0 +#define GC_USB_GUSBCFG_ULPIEVBUSD_OFFSET 0xc + +#define GC_USB_GUSBCFG_ULPIEVBUSI_LSB 21 +#define GC_USB_GUSBCFG_ULPIEVBUSI_MASK 0x200000 +#define GC_USB_GUSBCFG_ULPIEVBUSI_SIZE 0x1 +#define GC_USB_GUSBCFG_ULPIEVBUSI_DEFAULT 0x0 +#define GC_USB_GUSBCFG_ULPIEVBUSI_OFFSET 0xc + +#define GC_USB_GUSBCFG_TERMSELDLPULSE_LSB 22 +#define GC_USB_GUSBCFG_TERMSELDLPULSE_MASK 0x400000 +#define GC_USB_GUSBCFG_TERMSELDLPULSE_SIZE 0x1 +#define GC_USB_GUSBCFG_TERMSELDLPULSE_DEFAULT 0x0 +#define GC_USB_GUSBCFG_TERMSELDLPULSE_OFFSET 0xc + +#define GC_USB_GUSBCFG_PCCI_LSB 23 +#define GC_USB_GUSBCFG_PCCI_MASK (1 << 23) +#define GC_USB_GUSBCFG_PCCI_SIZE 0x1 +#define GC_USB_GUSBCFG_PCCI_DEFAULT 0x0 +#define GC_USB_GUSBCFG_PCCI_OFFSET 0xc + +#define GC_USB_GUSBCFG_PTCI_LSB 24 +#define GC_USB_GUSBCFG_PTCI_MASK (1 << 24) +#define GC_USB_GUSBCFG_PTCI_SIZE 0x1 +#define GC_USB_GUSBCFG_PTCI_DEFAULT 0x0 +#define GC_USB_GUSBCFG_PTCI_OFFSET 0xc + +#define GC_USB_GUSBCFG_ULPIIPD_LSB 25 +#define GC_USB_GUSBCFG_ULPIIPD_MASK (1 << 25) +#define GC_USB_GUSBCFG_ULPIIPD_SIZE 0x1 +#define GC_USB_GUSBCFG_ULPIIPD_DEFAULT 0x0 +#define GC_USB_GUSBCFG_ULPIIPD_OFFSET 0xc + +#define GC_USB_GUSBCFG_FHMOD_LSB 29 +#define GC_USB_GUSBCFG_FHMOD_MASK (1 << 29) +#define GC_USB_GUSBCFG_FHMOD_SIZE 0x1 +#define GC_USB_GUSBCFG_FHMOD_DEFAULT 0x0 +#define GC_USB_GUSBCFG_FHMOD_OFFSET 0xc + +#define GC_USB_GUSBCFG_FDMOD_LSB 30 +#define GC_USB_GUSBCFG_FDMOD_MASK (1 << 30) +#define GC_USB_GUSBCFG_FDMOD_SIZE 0x1 +#define GC_USB_GUSBCFG_FDMOD_DEFAULT 0x0 +#define GC_USB_GUSBCFG_FDMOD_OFFSET 0xc + +#define GC_USB_GRSTCTL_CSFTRST_LSB 0x0 +#define GC_USB_GRSTCTL_CSFTRST_MASK 0x1 +#define GC_USB_GRSTCTL_CSFTRST_SIZE 0x1 +#define GC_USB_GRSTCTL_CSFTRST_DEFAULT 0x0 +#define GC_USB_GRSTCTL_CSFTRST_OFFSET 0x10 +#define GC_USB_GRSTCTL_PIUFSSFTRST_LSB 0x1 +#define GC_USB_GRSTCTL_PIUFSSFTRST_MASK 0x2 +#define GC_USB_GRSTCTL_PIUFSSFTRST_SIZE 0x1 +#define GC_USB_GRSTCTL_PIUFSSFTRST_DEFAULT 0x0 +#define GC_USB_GRSTCTL_PIUFSSFTRST_OFFSET 0x10 +#define GC_USB_GRSTCTL_RXFFLSH_LSB 0x4 +#define GC_USB_GRSTCTL_RXFFLSH_MASK 0x10 +#define GC_USB_GRSTCTL_RXFFLSH_SIZE 0x1 +#define GC_USB_GRSTCTL_RXFFLSH_DEFAULT 0x0 +#define GC_USB_GRSTCTL_RXFFLSH_OFFSET 0x10 +#define GC_USB_GRSTCTL_TXFFLSH_LSB 0x5 +#define GC_USB_GRSTCTL_TXFFLSH_MASK 0x20 +#define GC_USB_GRSTCTL_TXFFLSH_SIZE 0x1 +#define GC_USB_GRSTCTL_TXFFLSH_DEFAULT 0x0 +#define GC_USB_GRSTCTL_TXFFLSH_OFFSET 0x10 +#define GC_USB_GRSTCTL_TXFNUM_LSB 0x6 +#define GC_USB_GRSTCTL_TXFNUM_MASK 0x7c0 +#define GC_USB_GRSTCTL_TXFNUM_SIZE 0x5 +#define GC_USB_GRSTCTL_TXFNUM_DEFAULT 0x0 +#define GC_USB_GRSTCTL_TXFNUM_OFFSET 0x10 +#define GC_USB_GRSTCTL_DMAREQ_LSB 0x1e +#define GC_USB_GRSTCTL_DMAREQ_MASK 0x40000000 +#define GC_USB_GRSTCTL_DMAREQ_SIZE 0x1 +#define GC_USB_GRSTCTL_DMAREQ_DEFAULT 0x0 +#define GC_USB_GRSTCTL_DMAREQ_OFFSET 0x10 +#define GC_USB_GRSTCTL_AHBIDLE_LSB 0x1f +#define GC_USB_GRSTCTL_AHBIDLE_MASK 0x80000000 +#define GC_USB_GRSTCTL_AHBIDLE_SIZE 0x1 +#define GC_USB_GRSTCTL_AHBIDLE_DEFAULT 0x0 +#define GC_USB_GRSTCTL_AHBIDLE_OFFSET 0x10 +#define GC_USB_GINTSTS_CURMOD_LSB 0x0 +#define GC_USB_GINTSTS_CURMOD_MASK 0x1 +#define GC_USB_GINTSTS_CURMOD_SIZE 0x1 +#define GC_USB_GINTSTS_CURMOD_DEFAULT 0x0 +#define GC_USB_GINTSTS_CURMOD_OFFSET 0x14 +#define GC_USB_GINTSTS_MODEMIS_LSB 0x1 +#define GC_USB_GINTSTS_MODEMIS_MASK 0x2 +#define GC_USB_GINTSTS_MODEMIS_SIZE 0x1 +#define GC_USB_GINTSTS_MODEMIS_DEFAULT 0x0 +#define GC_USB_GINTSTS_MODEMIS_OFFSET 0x14 +#define GC_USB_GINTSTS_OTGINT_LSB 0x2 +#define GC_USB_GINTSTS_OTGINT_MASK 0x4 +#define GC_USB_GINTSTS_OTGINT_SIZE 0x1 +#define GC_USB_GINTSTS_OTGINT_DEFAULT 0x0 +#define GC_USB_GINTSTS_OTGINT_OFFSET 0x14 +#define GC_USB_GINTSTS_SOF_LSB 0x3 +#define GC_USB_GINTSTS_SOF_MASK 0x8 +#define GC_USB_GINTSTS_SOF_SIZE 0x1 +#define GC_USB_GINTSTS_SOF_DEFAULT 0x0 +#define GC_USB_GINTSTS_SOF_OFFSET 0x14 +#define GC_USB_GINTSTS_RXFLVL_LSB 0x4 +#define GC_USB_GINTSTS_RXFLVL_MASK 0x10 +#define GC_USB_GINTSTS_RXFLVL_SIZE 0x1 +#define GC_USB_GINTSTS_RXFLVL_DEFAULT 0x0 +#define GC_USB_GINTSTS_RXFLVL_OFFSET 0x14 +#define GC_USB_GINTSTS_GINNAKEFF_LSB 0x6 +#define GC_USB_GINTSTS_GINNAKEFF_MASK 0x40 +#define GC_USB_GINTSTS_GINNAKEFF_SIZE 0x1 +#define GC_USB_GINTSTS_GINNAKEFF_DEFAULT 0x0 +#define GC_USB_GINTSTS_GINNAKEFF_OFFSET 0x14 +#define GC_USB_GINTSTS_GOUTNAKEFF_LSB 0x7 +#define GC_USB_GINTSTS_GOUTNAKEFF_MASK 0x80 +#define GC_USB_GINTSTS_GOUTNAKEFF_SIZE 0x1 +#define GC_USB_GINTSTS_GOUTNAKEFF_DEFAULT 0x0 +#define GC_USB_GINTSTS_GOUTNAKEFF_OFFSET 0x14 +#define GC_USB_GINTSTS_ERLYSUSP_LSB 0xa +#define GC_USB_GINTSTS_ERLYSUSP_MASK 0x400 +#define GC_USB_GINTSTS_ERLYSUSP_SIZE 0x1 +#define GC_USB_GINTSTS_ERLYSUSP_DEFAULT 0x0 +#define GC_USB_GINTSTS_ERLYSUSP_OFFSET 0x14 +#define GC_USB_GINTSTS_USBSUSP_LSB 0xb +#define GC_USB_GINTSTS_USBSUSP_MASK 0x800 +#define GC_USB_GINTSTS_USBSUSP_SIZE 0x1 +#define GC_USB_GINTSTS_USBSUSP_DEFAULT 0x0 +#define GC_USB_GINTSTS_USBSUSP_OFFSET 0x14 +#define GC_USB_GINTSTS_USBRST_LSB 0xc +#define GC_USB_GINTSTS_USBRST_MASK 0x1000 +#define GC_USB_GINTSTS_USBRST_SIZE 0x1 +#define GC_USB_GINTSTS_USBRST_DEFAULT 0x0 +#define GC_USB_GINTSTS_USBRST_OFFSET 0x14 +#define GC_USB_GINTSTS_ENUMDONE_LSB 0xd +#define GC_USB_GINTSTS_ENUMDONE_MASK 0x2000 +#define GC_USB_GINTSTS_ENUMDONE_SIZE 0x1 +#define GC_USB_GINTSTS_ENUMDONE_DEFAULT 0x0 +#define GC_USB_GINTSTS_ENUMDONE_OFFSET 0x14 +#define GC_USB_GINTSTS_ISOOUTDROP_LSB 0xe +#define GC_USB_GINTSTS_ISOOUTDROP_MASK 0x4000 +#define GC_USB_GINTSTS_ISOOUTDROP_SIZE 0x1 +#define GC_USB_GINTSTS_ISOOUTDROP_DEFAULT 0x0 +#define GC_USB_GINTSTS_ISOOUTDROP_OFFSET 0x14 +#define GC_USB_GINTSTS_EOPF_LSB 0xf +#define GC_USB_GINTSTS_EOPF_MASK 0x8000 +#define GC_USB_GINTSTS_EOPF_SIZE 0x1 +#define GC_USB_GINTSTS_EOPF_DEFAULT 0x0 +#define GC_USB_GINTSTS_EOPF_OFFSET 0x14 +#define GC_USB_GINTSTS_EPMIS_LSB 0x11 +#define GC_USB_GINTSTS_EPMIS_MASK 0x20000 +#define GC_USB_GINTSTS_EPMIS_SIZE 0x1 +#define GC_USB_GINTSTS_EPMIS_DEFAULT 0x0 +#define GC_USB_GINTSTS_EPMIS_OFFSET 0x14 +#define GC_USB_GINTSTS_IEPINT_LSB 0x12 +#define GC_USB_GINTSTS_IEPINT_MASK 0x40000 +#define GC_USB_GINTSTS_IEPINT_SIZE 0x1 +#define GC_USB_GINTSTS_IEPINT_DEFAULT 0x0 +#define GC_USB_GINTSTS_IEPINT_OFFSET 0x14 +#define GC_USB_GINTSTS_OEPINT_LSB 0x13 +#define GC_USB_GINTSTS_OEPINT_MASK 0x80000 +#define GC_USB_GINTSTS_OEPINT_SIZE 0x1 +#define GC_USB_GINTSTS_OEPINT_DEFAULT 0x0 +#define GC_USB_GINTSTS_OEPINT_OFFSET 0x14 +#define GC_USB_GINTSTS_INCOMPISOIN_LSB 0x14 +#define GC_USB_GINTSTS_INCOMPISOIN_MASK 0x100000 +#define GC_USB_GINTSTS_INCOMPISOIN_SIZE 0x1 +#define GC_USB_GINTSTS_INCOMPISOIN_DEFAULT 0x0 +#define GC_USB_GINTSTS_INCOMPISOIN_OFFSET 0x14 +#define GC_USB_GINTSTS_INCOMPLP_LSB 0x15 +#define GC_USB_GINTSTS_INCOMPLP_MASK 0x200000 +#define GC_USB_GINTSTS_INCOMPLP_SIZE 0x1 +#define GC_USB_GINTSTS_INCOMPLP_DEFAULT 0x0 +#define GC_USB_GINTSTS_INCOMPLP_OFFSET 0x14 +#define GC_USB_GINTSTS_FETSUSP_LSB 0x16 +#define GC_USB_GINTSTS_FETSUSP_MASK 0x400000 +#define GC_USB_GINTSTS_FETSUSP_SIZE 0x1 +#define GC_USB_GINTSTS_FETSUSP_DEFAULT 0x0 +#define GC_USB_GINTSTS_FETSUSP_OFFSET 0x14 +#define GC_USB_GINTSTS_RESETDET_LSB 0x17 +#define GC_USB_GINTSTS_RESETDET_MASK 0x800000 +#define GC_USB_GINTSTS_RESETDET_SIZE 0x1 +#define GC_USB_GINTSTS_RESETDET_DEFAULT 0x0 +#define GC_USB_GINTSTS_RESETDET_OFFSET 0x14 +#define GC_USB_GINTSTS_CONIDSTSCHNG_LSB 0x1c +#define GC_USB_GINTSTS_CONIDSTSCHNG_MASK 0x10000000 +#define GC_USB_GINTSTS_CONIDSTSCHNG_SIZE 0x1 +#define GC_USB_GINTSTS_CONIDSTSCHNG_DEFAULT 0x0 +#define GC_USB_GINTSTS_CONIDSTSCHNG_OFFSET 0x14 +#define GC_USB_GINTSTS_SESSREQINT_LSB 0x1e +#define GC_USB_GINTSTS_SESSREQINT_MASK 0x40000000 +#define GC_USB_GINTSTS_SESSREQINT_SIZE 0x1 +#define GC_USB_GINTSTS_SESSREQINT_DEFAULT 0x0 +#define GC_USB_GINTSTS_SESSREQINT_OFFSET 0x14 +#define GC_USB_GINTSTS_WKUPINT_LSB 0x1f +#define GC_USB_GINTSTS_WKUPINT_MASK 0x80000000 +#define GC_USB_GINTSTS_WKUPINT_SIZE 0x1 +#define GC_USB_GINTSTS_WKUPINT_DEFAULT 0x0 +#define GC_USB_GINTSTS_WKUPINT_OFFSET 0x14 +#define GC_USB_GINTMSK_MODEMISMSK_LSB 0x1 +#define GC_USB_GINTMSK_MODEMISMSK_MASK 0x2 +#define GC_USB_GINTMSK_MODEMISMSK_SIZE 0x1 +#define GC_USB_GINTMSK_MODEMISMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_MODEMISMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_OTGINTMSK_LSB 0x2 +#define GC_USB_GINTMSK_OTGINTMSK_MASK 0x4 +#define GC_USB_GINTMSK_OTGINTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_OTGINTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_OTGINTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_SOFMSK_LSB 0x3 +#define GC_USB_GINTMSK_SOFMSK_MASK 0x8 +#define GC_USB_GINTMSK_SOFMSK_SIZE 0x1 +#define GC_USB_GINTMSK_SOFMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_SOFMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_RXFLVLMSK_LSB 0x4 +#define GC_USB_GINTMSK_RXFLVLMSK_MASK 0x10 +#define GC_USB_GINTMSK_RXFLVLMSK_SIZE 0x1 +#define GC_USB_GINTMSK_RXFLVLMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_RXFLVLMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_UNKNOWN5_LSB 0x5 +#define GC_USB_GINTMSK_UNKNOWN5_MASK 0x20 +#define GC_USB_GINTMSK_UNKNOWN5_SIZE 0x1 +#define GC_USB_GINTMSK_UNKNOWN5_DEFAULT 0x0 +#define GC_USB_GINTMSK_UNKNOWN5_OFFSET 0x18 +#define GC_USB_GINTMSK_GINNAKEFFMSK_LSB 0x6 +#define GC_USB_GINTMSK_GINNAKEFFMSK_MASK 0x40 +#define GC_USB_GINTMSK_GINNAKEFFMSK_SIZE 0x1 +#define GC_USB_GINTMSK_GINNAKEFFMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_GINNAKEFFMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_GOUTNAKEFFMSK_LSB 0x7 +#define GC_USB_GINTMSK_GOUTNAKEFFMSK_MASK 0x80 +#define GC_USB_GINTMSK_GOUTNAKEFFMSK_SIZE 0x1 +#define GC_USB_GINTMSK_GOUTNAKEFFMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_GOUTNAKEFFMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_ERLYSUSPMSK_LSB 0xa +#define GC_USB_GINTMSK_ERLYSUSPMSK_MASK 0x400 +#define GC_USB_GINTMSK_ERLYSUSPMSK_SIZE 0x1 +#define GC_USB_GINTMSK_ERLYSUSPMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_ERLYSUSPMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_USBSUSPMSK_LSB 0xb +#define GC_USB_GINTMSK_USBSUSPMSK_MASK 0x800 +#define GC_USB_GINTMSK_USBSUSPMSK_SIZE 0x1 +#define GC_USB_GINTMSK_USBSUSPMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_USBSUSPMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_USBRSTMSK_LSB 0xc +#define GC_USB_GINTMSK_USBRSTMSK_MASK 0x1000 +#define GC_USB_GINTMSK_USBRSTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_USBRSTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_USBRSTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_ENUMDONEMSK_LSB 0xd +#define GC_USB_GINTMSK_ENUMDONEMSK_MASK 0x2000 +#define GC_USB_GINTMSK_ENUMDONEMSK_SIZE 0x1 +#define GC_USB_GINTMSK_ENUMDONEMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_ENUMDONEMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_ISOOUTDROPMSK_LSB 0xe +#define GC_USB_GINTMSK_ISOOUTDROPMSK_MASK 0x4000 +#define GC_USB_GINTMSK_ISOOUTDROPMSK_SIZE 0x1 +#define GC_USB_GINTMSK_ISOOUTDROPMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_ISOOUTDROPMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_EOPFMSK_LSB 0xf +#define GC_USB_GINTMSK_EOPFMSK_MASK 0x8000 +#define GC_USB_GINTMSK_EOPFMSK_SIZE 0x1 +#define GC_USB_GINTMSK_EOPFMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_EOPFMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_UNKNOWN16_LSB 0x10 +#define GC_USB_GINTMSK_UNKNOWN16_MASK 0x10000 +#define GC_USB_GINTMSK_UNKNOWN16_SIZE 0x1 +#define GC_USB_GINTMSK_UNKNOWN16_DEFAULT 0x0 +#define GC_USB_GINTMSK_UNKNOWN16_OFFSET 0x18 +#define GC_USB_GINTMSK_EPMISMSK_LSB 0x11 +#define GC_USB_GINTMSK_EPMISMSK_MASK 0x20000 +#define GC_USB_GINTMSK_EPMISMSK_SIZE 0x1 +#define GC_USB_GINTMSK_EPMISMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_EPMISMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_IEPINTMSK_LSB 0x12 +#define GC_USB_GINTMSK_IEPINTMSK_MASK 0x40000 +#define GC_USB_GINTMSK_IEPINTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_IEPINTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_IEPINTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_OEPINTMSK_LSB 0x13 +#define GC_USB_GINTMSK_OEPINTMSK_MASK 0x80000 +#define GC_USB_GINTMSK_OEPINTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_OEPINTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_OEPINTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_INCOMPISOINMSK_LSB 0x14 +#define GC_USB_GINTMSK_INCOMPISOINMSK_MASK 0x100000 +#define GC_USB_GINTMSK_INCOMPISOINMSK_SIZE 0x1 +#define GC_USB_GINTMSK_INCOMPISOINMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_INCOMPISOINMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_INCOMPLISOOUTMSK_LSB 0x15 +#define GC_USB_GINTMSK_INCOMPLISOOUTMSK_MASK 0x200000 +#define GC_USB_GINTMSK_INCOMPLISOOUTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_INCOMPLISOOUTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_INCOMPLISOOUTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_FETSUSPMSK_LSB 0x16 +#define GC_USB_GINTMSK_FETSUSPMSK_MASK 0x400000 +#define GC_USB_GINTMSK_FETSUSPMSK_SIZE 0x1 +#define GC_USB_GINTMSK_FETSUSPMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_FETSUSPMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_RESETDETMSK_LSB 0x17 +#define GC_USB_GINTMSK_RESETDETMSK_MASK 0x800000 +#define GC_USB_GINTMSK_RESETDETMSK_SIZE 0x1 +#define GC_USB_GINTMSK_RESETDETMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_RESETDETMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_CONIDSTSCHNGMSK_LSB 0x1c +#define GC_USB_GINTMSK_CONIDSTSCHNGMSK_MASK 0x10000000 +#define GC_USB_GINTMSK_CONIDSTSCHNGMSK_SIZE 0x1 +#define GC_USB_GINTMSK_CONIDSTSCHNGMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_CONIDSTSCHNGMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_DISCONNINTMSK_LSB 0x1d +#define GC_USB_GINTMSK_DISCONNINTMSK_MASK 0x20000000 +#define GC_USB_GINTMSK_DISCONNINTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_DISCONNINTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_DISCONNINTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_SESSREQINTMSK_LSB 0x1e +#define GC_USB_GINTMSK_SESSREQINTMSK_MASK 0x40000000 +#define GC_USB_GINTMSK_SESSREQINTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_SESSREQINTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_SESSREQINTMSK_OFFSET 0x18 +#define GC_USB_GINTMSK_WKUPINTMSK_LSB 0x1f +#define GC_USB_GINTMSK_WKUPINTMSK_MASK 0x80000000 +#define GC_USB_GINTMSK_WKUPINTMSK_SIZE 0x1 +#define GC_USB_GINTMSK_WKUPINTMSK_DEFAULT 0x0 +#define GC_USB_GINTMSK_WKUPINTMSK_OFFSET 0x18 +#define GC_USB_GRXSTSR_CHNUM_LSB 0x0 +#define GC_USB_GRXSTSR_CHNUM_MASK 0xf +#define GC_USB_GRXSTSR_CHNUM_SIZE 0x4 +#define GC_USB_GRXSTSR_CHNUM_DEFAULT 0x0 +#define GC_USB_GRXSTSR_CHNUM_OFFSET 0x1c +#define GC_USB_GRXSTSR_BCNT_LSB 0x4 +#define GC_USB_GRXSTSR_BCNT_MASK 0x7ff0 +#define GC_USB_GRXSTSR_BCNT_SIZE 0xb +#define GC_USB_GRXSTSR_BCNT_DEFAULT 0x0 +#define GC_USB_GRXSTSR_BCNT_OFFSET 0x1c +#define GC_USB_GRXSTSR_DPID_LSB 0xf +#define GC_USB_GRXSTSR_DPID_MASK 0x18000 +#define GC_USB_GRXSTSR_DPID_SIZE 0x2 +#define GC_USB_GRXSTSR_DPID_DEFAULT 0x0 +#define GC_USB_GRXSTSR_DPID_OFFSET 0x1c +#define GC_USB_GRXSTSR_PKTSTS_LSB 0x11 +#define GC_USB_GRXSTSR_PKTSTS_MASK 0x1e0000 +#define GC_USB_GRXSTSR_PKTSTS_SIZE 0x4 +#define GC_USB_GRXSTSR_PKTSTS_DEFAULT 0x0 +#define GC_USB_GRXSTSR_PKTSTS_OFFSET 0x1c +#define GC_USB_GRXSTSR_FN_LSB 0x15 +#define GC_USB_GRXSTSR_FN_MASK 0x1e00000 +#define GC_USB_GRXSTSR_FN_SIZE 0x4 +#define GC_USB_GRXSTSR_FN_DEFAULT 0x0 +#define GC_USB_GRXSTSR_FN_OFFSET 0x1c +#define GC_USB_GRXSTSP_CHNUM_LSB 0x0 +#define GC_USB_GRXSTSP_CHNUM_MASK 0xf +#define GC_USB_GRXSTSP_CHNUM_SIZE 0x4 +#define GC_USB_GRXSTSP_CHNUM_DEFAULT 0x0 +#define GC_USB_GRXSTSP_CHNUM_OFFSET 0x20 +#define GC_USB_GRXSTSP_BCNT_LSB 0x4 +#define GC_USB_GRXSTSP_BCNT_MASK 0x7ff0 +#define GC_USB_GRXSTSP_BCNT_SIZE 0xb +#define GC_USB_GRXSTSP_BCNT_DEFAULT 0x0 +#define GC_USB_GRXSTSP_BCNT_OFFSET 0x20 +#define GC_USB_GRXSTSP_DPID_LSB 0xf +#define GC_USB_GRXSTSP_DPID_MASK 0x18000 +#define GC_USB_GRXSTSP_DPID_SIZE 0x2 +#define GC_USB_GRXSTSP_DPID_DEFAULT 0x0 +#define GC_USB_GRXSTSP_DPID_OFFSET 0x20 +#define GC_USB_GRXSTSP_PKTSTS_LSB 0x11 +#define GC_USB_GRXSTSP_PKTSTS_MASK 0x1e0000 +#define GC_USB_GRXSTSP_PKTSTS_SIZE 0x4 +#define GC_USB_GRXSTSP_PKTSTS_DEFAULT 0x0 +#define GC_USB_GRXSTSP_PKTSTS_OFFSET 0x20 +#define GC_USB_GRXSTSP_FN_LSB 0x15 +#define GC_USB_GRXSTSP_FN_MASK 0x1e00000 +#define GC_USB_GRXSTSP_FN_SIZE 0x4 +#define GC_USB_GRXSTSP_FN_DEFAULT 0x0 +#define GC_USB_GRXSTSP_FN_OFFSET 0x20 +#define GC_USB_GRXFSIZ_RXFDEP_LSB 0x0 +#define GC_USB_GRXFSIZ_RXFDEP_MASK 0x7ff +#define GC_USB_GRXFSIZ_RXFDEP_SIZE 0xb +#define GC_USB_GRXFSIZ_RXFDEP_DEFAULT 0x0 +#define GC_USB_GRXFSIZ_RXFDEP_OFFSET 0x24 +#define GC_USB_GNPTXFSIZ_INEPTXF0STADDR_LSB 0x0 +#define GC_USB_GNPTXFSIZ_INEPTXF0STADDR_MASK 0xffff +#define GC_USB_GNPTXFSIZ_INEPTXF0STADDR_SIZE 0x10 +#define GC_USB_GNPTXFSIZ_INEPTXF0STADDR_DEFAULT 0x0 +#define GC_USB_GNPTXFSIZ_INEPTXF0STADDR_OFFSET 0x28 +#define GC_USB_GNPTXFSIZ_INEPTXF0DEP_LSB 0x10 +#define GC_USB_GNPTXFSIZ_INEPTXF0DEP_MASK 0xffff0000 +#define GC_USB_GNPTXFSIZ_INEPTXF0DEP_SIZE 0x10 +#define GC_USB_GNPTXFSIZ_INEPTXF0DEP_DEFAULT 0x0 +#define GC_USB_GNPTXFSIZ_INEPTXF0DEP_OFFSET 0x28 + +#define GC_USB_GUID_GUID_LSB 0x0 +#define GC_USB_GUID_GUID_MASK 0xffffffff +#define GC_USB_GUID_GUID_SIZE 0x20 +#define GC_USB_GUID_GUID_DEFAULT 0x0 +#define GC_USB_GUID_GUID_OFFSET 0x3c +#define GC_USB_GSNPSID_SYNOPSYSID_LSB 0x0 +#define GC_USB_GSNPSID_SYNOPSYSID_MASK 0xffffffff +#define GC_USB_GSNPSID_SYNOPSYSID_SIZE 0x20 +#define GC_USB_GSNPSID_SYNOPSYSID_DEFAULT 0x0 +#define GC_USB_GSNPSID_SYNOPSYSID_OFFSET 0x40 +#define GC_USB_GHWCFG1_EPDIR_LSB 0x0 +#define GC_USB_GHWCFG1_EPDIR_MASK 0xffffffff +#define GC_USB_GHWCFG1_EPDIR_SIZE 0x20 +#define GC_USB_GHWCFG1_EPDIR_DEFAULT 0x0 +#define GC_USB_GHWCFG1_EPDIR_OFFSET 0x44 +#define GC_USB_GHWCFG2_OTGMODE_LSB 0x0 +#define GC_USB_GHWCFG2_OTGMODE_MASK 0x7 +#define GC_USB_GHWCFG2_OTGMODE_SIZE 0x3 +#define GC_USB_GHWCFG2_OTGMODE_DEFAULT 0x0 +#define GC_USB_GHWCFG2_OTGMODE_OFFSET 0x48 +#define GC_USB_GHWCFG2_OTGARCH_LSB 0x3 +#define GC_USB_GHWCFG2_OTGARCH_MASK 0x18 +#define GC_USB_GHWCFG2_OTGARCH_SIZE 0x2 +#define GC_USB_GHWCFG2_OTGARCH_DEFAULT 0x0 +#define GC_USB_GHWCFG2_OTGARCH_OFFSET 0x48 +#define GC_USB_GHWCFG2_SINGPNT_LSB 0x5 +#define GC_USB_GHWCFG2_SINGPNT_MASK 0x20 +#define GC_USB_GHWCFG2_SINGPNT_SIZE 0x1 +#define GC_USB_GHWCFG2_SINGPNT_DEFAULT 0x0 +#define GC_USB_GHWCFG2_SINGPNT_OFFSET 0x48 +#define GC_USB_GHWCFG2_HSPHYTYPE_LSB 0x6 +#define GC_USB_GHWCFG2_HSPHYTYPE_MASK 0xc0 +#define GC_USB_GHWCFG2_HSPHYTYPE_SIZE 0x2 +#define GC_USB_GHWCFG2_HSPHYTYPE_DEFAULT 0x0 +#define GC_USB_GHWCFG2_HSPHYTYPE_OFFSET 0x48 +#define GC_USB_GHWCFG2_FSPHYTYPE_LSB 0x8 +#define GC_USB_GHWCFG2_FSPHYTYPE_MASK 0x300 +#define GC_USB_GHWCFG2_FSPHYTYPE_SIZE 0x2 +#define GC_USB_GHWCFG2_FSPHYTYPE_DEFAULT 0x0 +#define GC_USB_GHWCFG2_FSPHYTYPE_OFFSET 0x48 +#define GC_USB_GHWCFG2_NUMDEVEPS_LSB 0xa +#define GC_USB_GHWCFG2_NUMDEVEPS_MASK 0x3c00 +#define GC_USB_GHWCFG2_NUMDEVEPS_SIZE 0x4 +#define GC_USB_GHWCFG2_NUMDEVEPS_DEFAULT 0x0 +#define GC_USB_GHWCFG2_NUMDEVEPS_OFFSET 0x48 +#define GC_USB_GHWCFG2_NUMHSTCHNL_LSB 0xe +#define GC_USB_GHWCFG2_NUMHSTCHNL_MASK 0x3c000 +#define GC_USB_GHWCFG2_NUMHSTCHNL_SIZE 0x4 +#define GC_USB_GHWCFG2_NUMHSTCHNL_DEFAULT 0x0 +#define GC_USB_GHWCFG2_NUMHSTCHNL_OFFSET 0x48 +#define GC_USB_GHWCFG2_PERIOSUPPORT_LSB 0x12 +#define GC_USB_GHWCFG2_PERIOSUPPORT_MASK 0x40000 +#define GC_USB_GHWCFG2_PERIOSUPPORT_SIZE 0x1 +#define GC_USB_GHWCFG2_PERIOSUPPORT_DEFAULT 0x0 +#define GC_USB_GHWCFG2_PERIOSUPPORT_OFFSET 0x48 +#define GC_USB_GHWCFG2_DYNFIFOSIZING_LSB 0x13 +#define GC_USB_GHWCFG2_DYNFIFOSIZING_MASK 0x80000 +#define GC_USB_GHWCFG2_DYNFIFOSIZING_SIZE 0x1 +#define GC_USB_GHWCFG2_DYNFIFOSIZING_DEFAULT 0x0 +#define GC_USB_GHWCFG2_DYNFIFOSIZING_OFFSET 0x48 +#define GC_USB_GHWCFG2_MULTIPROCINTRPT_LSB 0x14 +#define GC_USB_GHWCFG2_MULTIPROCINTRPT_MASK 0x100000 +#define GC_USB_GHWCFG2_MULTIPROCINTRPT_SIZE 0x1 +#define GC_USB_GHWCFG2_MULTIPROCINTRPT_DEFAULT 0x0 +#define GC_USB_GHWCFG2_MULTIPROCINTRPT_OFFSET 0x48 +#define GC_USB_GHWCFG2_NPTXQDEPTH_LSB 0x16 +#define GC_USB_GHWCFG2_NPTXQDEPTH_MASK 0xc00000 +#define GC_USB_GHWCFG2_NPTXQDEPTH_SIZE 0x2 +#define GC_USB_GHWCFG2_NPTXQDEPTH_DEFAULT 0x0 +#define GC_USB_GHWCFG2_NPTXQDEPTH_OFFSET 0x48 +#define GC_USB_GHWCFG2_PTXQDEPTH_LSB 0x18 +#define GC_USB_GHWCFG2_PTXQDEPTH_MASK 0x3000000 +#define GC_USB_GHWCFG2_PTXQDEPTH_SIZE 0x2 +#define GC_USB_GHWCFG2_PTXQDEPTH_DEFAULT 0x0 +#define GC_USB_GHWCFG2_PTXQDEPTH_OFFSET 0x48 +#define GC_USB_GHWCFG2_TKNQDEPTH_LSB 0x1a +#define GC_USB_GHWCFG2_TKNQDEPTH_MASK 0x7c000000 +#define GC_USB_GHWCFG2_TKNQDEPTH_SIZE 0x5 +#define GC_USB_GHWCFG2_TKNQDEPTH_DEFAULT 0x0 +#define GC_USB_GHWCFG2_TKNQDEPTH_OFFSET 0x48 +#define GC_USB_GHWCFG3_XFERSIZEWIDTH_LSB 0x0 +#define GC_USB_GHWCFG3_XFERSIZEWIDTH_MASK 0xf +#define GC_USB_GHWCFG3_XFERSIZEWIDTH_SIZE 0x4 +#define GC_USB_GHWCFG3_XFERSIZEWIDTH_DEFAULT 0x0 +#define GC_USB_GHWCFG3_XFERSIZEWIDTH_OFFSET 0x4c +#define GC_USB_GHWCFG3_PKTSIZEWIDTH_LSB 0x4 +#define GC_USB_GHWCFG3_PKTSIZEWIDTH_MASK 0x70 +#define GC_USB_GHWCFG3_PKTSIZEWIDTH_SIZE 0x3 +#define GC_USB_GHWCFG3_PKTSIZEWIDTH_DEFAULT 0x0 +#define GC_USB_GHWCFG3_PKTSIZEWIDTH_OFFSET 0x4c +#define GC_USB_GHWCFG3_OTGEN_LSB 0x7 +#define GC_USB_GHWCFG3_OTGEN_MASK 0x80 +#define GC_USB_GHWCFG3_OTGEN_SIZE 0x1 +#define GC_USB_GHWCFG3_OTGEN_DEFAULT 0x0 +#define GC_USB_GHWCFG3_OTGEN_OFFSET 0x4c +#define GC_USB_GHWCFG3_I2CINTSEL_LSB 0x8 +#define GC_USB_GHWCFG3_I2CINTSEL_MASK 0x100 +#define GC_USB_GHWCFG3_I2CINTSEL_SIZE 0x1 +#define GC_USB_GHWCFG3_I2CINTSEL_DEFAULT 0x0 +#define GC_USB_GHWCFG3_I2CINTSEL_OFFSET 0x4c +#define GC_USB_GHWCFG3_VNDCTLSUPT_LSB 0x9 +#define GC_USB_GHWCFG3_VNDCTLSUPT_MASK 0x200 +#define GC_USB_GHWCFG3_VNDCTLSUPT_SIZE 0x1 +#define GC_USB_GHWCFG3_VNDCTLSUPT_DEFAULT 0x0 +#define GC_USB_GHWCFG3_VNDCTLSUPT_OFFSET 0x4c +#define GC_USB_GHWCFG3_OPTFEATURE_LSB 0xa +#define GC_USB_GHWCFG3_OPTFEATURE_MASK 0x400 +#define GC_USB_GHWCFG3_OPTFEATURE_SIZE 0x1 +#define GC_USB_GHWCFG3_OPTFEATURE_DEFAULT 0x0 +#define GC_USB_GHWCFG3_OPTFEATURE_OFFSET 0x4c +#define GC_USB_GHWCFG3_RSTTYPE_LSB 0xb +#define GC_USB_GHWCFG3_RSTTYPE_MASK 0x800 +#define GC_USB_GHWCFG3_RSTTYPE_SIZE 0x1 +#define GC_USB_GHWCFG3_RSTTYPE_DEFAULT 0x0 +#define GC_USB_GHWCFG3_RSTTYPE_OFFSET 0x4c +#define GC_USB_GHWCFG3_ADPSUPPORT_LSB 0xc +#define GC_USB_GHWCFG3_ADPSUPPORT_MASK 0x1000 +#define GC_USB_GHWCFG3_ADPSUPPORT_SIZE 0x1 +#define GC_USB_GHWCFG3_ADPSUPPORT_DEFAULT 0x0 +#define GC_USB_GHWCFG3_ADPSUPPORT_OFFSET 0x4c +#define GC_USB_GHWCFG3_HSICMODE_LSB 0xd +#define GC_USB_GHWCFG3_HSICMODE_MASK 0x2000 +#define GC_USB_GHWCFG3_HSICMODE_SIZE 0x1 +#define GC_USB_GHWCFG3_HSICMODE_DEFAULT 0x0 +#define GC_USB_GHWCFG3_HSICMODE_OFFSET 0x4c +#define GC_USB_GHWCFG3_BCSUPPORT_LSB 0xe +#define GC_USB_GHWCFG3_BCSUPPORT_MASK 0x4000 +#define GC_USB_GHWCFG3_BCSUPPORT_SIZE 0x1 +#define GC_USB_GHWCFG3_BCSUPPORT_DEFAULT 0x0 +#define GC_USB_GHWCFG3_BCSUPPORT_OFFSET 0x4c +#define GC_USB_GHWCFG3_LPMMODE_LSB 0xf +#define GC_USB_GHWCFG3_LPMMODE_MASK 0x8000 +#define GC_USB_GHWCFG3_LPMMODE_SIZE 0x1 +#define GC_USB_GHWCFG3_LPMMODE_DEFAULT 0x0 +#define GC_USB_GHWCFG3_LPMMODE_OFFSET 0x4c +#define GC_USB_GHWCFG3_DFIFODEPTH_LSB 0x10 +#define GC_USB_GHWCFG3_DFIFODEPTH_MASK 0xffff0000 +#define GC_USB_GHWCFG3_DFIFODEPTH_SIZE 0x10 +#define GC_USB_GHWCFG3_DFIFODEPTH_DEFAULT 0x0 +#define GC_USB_GHWCFG3_DFIFODEPTH_OFFSET 0x4c +#define GC_USB_GHWCFG4_NUMDEVPERIOEPS_LSB 0x0 +#define GC_USB_GHWCFG4_NUMDEVPERIOEPS_MASK 0xf +#define GC_USB_GHWCFG4_NUMDEVPERIOEPS_SIZE 0x4 +#define GC_USB_GHWCFG4_NUMDEVPERIOEPS_DEFAULT 0x0 +#define GC_USB_GHWCFG4_NUMDEVPERIOEPS_OFFSET 0x50 +#define GC_USB_GHWCFG4_PARTIALPWRDN_LSB 0x4 +#define GC_USB_GHWCFG4_PARTIALPWRDN_MASK 0x10 +#define GC_USB_GHWCFG4_PARTIALPWRDN_SIZE 0x1 +#define GC_USB_GHWCFG4_PARTIALPWRDN_DEFAULT 0x0 +#define GC_USB_GHWCFG4_PARTIALPWRDN_OFFSET 0x50 +#define GC_USB_GHWCFG4_AHBFREQ_LSB 0x5 +#define GC_USB_GHWCFG4_AHBFREQ_MASK 0x20 +#define GC_USB_GHWCFG4_AHBFREQ_SIZE 0x1 +#define GC_USB_GHWCFG4_AHBFREQ_DEFAULT 0x0 +#define GC_USB_GHWCFG4_AHBFREQ_OFFSET 0x50 +#define GC_USB_GHWCFG4_HIBERNATION_LSB 0x6 +#define GC_USB_GHWCFG4_HIBERNATION_MASK 0x40 +#define GC_USB_GHWCFG4_HIBERNATION_SIZE 0x1 +#define GC_USB_GHWCFG4_HIBERNATION_DEFAULT 0x0 +#define GC_USB_GHWCFG4_HIBERNATION_OFFSET 0x50 +#define GC_USB_GHWCFG4_EXTENDEDHIBERNATION_LSB 0x7 +#define GC_USB_GHWCFG4_EXTENDEDHIBERNATION_MASK 0x80 +#define GC_USB_GHWCFG4_EXTENDEDHIBERNATION_SIZE 0x1 +#define GC_USB_GHWCFG4_EXTENDEDHIBERNATION_DEFAULT 0x0 +#define GC_USB_GHWCFG4_EXTENDEDHIBERNATION_OFFSET 0x50 +#define GC_USB_GHWCFG4_PHYDATAWIDTH_LSB 0xe +#define GC_USB_GHWCFG4_PHYDATAWIDTH_MASK 0xc000 +#define GC_USB_GHWCFG4_PHYDATAWIDTH_SIZE 0x2 +#define GC_USB_GHWCFG4_PHYDATAWIDTH_DEFAULT 0x0 +#define GC_USB_GHWCFG4_PHYDATAWIDTH_OFFSET 0x50 +#define GC_USB_GHWCFG4_NUMCTLEPS_LSB 0x10 +#define GC_USB_GHWCFG4_NUMCTLEPS_MASK 0xf0000 +#define GC_USB_GHWCFG4_NUMCTLEPS_SIZE 0x4 +#define GC_USB_GHWCFG4_NUMCTLEPS_DEFAULT 0x0 +#define GC_USB_GHWCFG4_NUMCTLEPS_OFFSET 0x50 +#define GC_USB_GHWCFG4_IDDGFLTR_LSB 0x14 +#define GC_USB_GHWCFG4_IDDGFLTR_MASK 0x100000 +#define GC_USB_GHWCFG4_IDDGFLTR_SIZE 0x1 +#define GC_USB_GHWCFG4_IDDGFLTR_DEFAULT 0x0 +#define GC_USB_GHWCFG4_IDDGFLTR_OFFSET 0x50 +#define GC_USB_GHWCFG4_VBUSVALIDFLTR_LSB 0x15 +#define GC_USB_GHWCFG4_VBUSVALIDFLTR_MASK 0x200000 +#define GC_USB_GHWCFG4_VBUSVALIDFLTR_SIZE 0x1 +#define GC_USB_GHWCFG4_VBUSVALIDFLTR_DEFAULT 0x0 +#define GC_USB_GHWCFG4_VBUSVALIDFLTR_OFFSET 0x50 +#define GC_USB_GHWCFG4_AVALIDFLTR_LSB 0x16 +#define GC_USB_GHWCFG4_AVALIDFLTR_MASK 0x400000 +#define GC_USB_GHWCFG4_AVALIDFLTR_SIZE 0x1 +#define GC_USB_GHWCFG4_AVALIDFLTR_DEFAULT 0x0 +#define GC_USB_GHWCFG4_AVALIDFLTR_OFFSET 0x50 +#define GC_USB_GHWCFG4_BVALIDFLTR_LSB 0x17 +#define GC_USB_GHWCFG4_BVALIDFLTR_MASK 0x800000 +#define GC_USB_GHWCFG4_BVALIDFLTR_SIZE 0x1 +#define GC_USB_GHWCFG4_BVALIDFLTR_DEFAULT 0x0 +#define GC_USB_GHWCFG4_BVALIDFLTR_OFFSET 0x50 +#define GC_USB_GHWCFG4_SESSENDFLTR_LSB 0x18 +#define GC_USB_GHWCFG4_SESSENDFLTR_MASK 0x1000000 +#define GC_USB_GHWCFG4_SESSENDFLTR_SIZE 0x1 +#define GC_USB_GHWCFG4_SESSENDFLTR_DEFAULT 0x0 +#define GC_USB_GHWCFG4_SESSENDFLTR_OFFSET 0x50 +#define GC_USB_GHWCFG4_DEDFIFOMODE_LSB 0x19 +#define GC_USB_GHWCFG4_DEDFIFOMODE_MASK 0x2000000 +#define GC_USB_GHWCFG4_DEDFIFOMODE_SIZE 0x1 +#define GC_USB_GHWCFG4_DEDFIFOMODE_DEFAULT 0x0 +#define GC_USB_GHWCFG4_DEDFIFOMODE_OFFSET 0x50 +#define GC_USB_GHWCFG4_INEPS_LSB 0x1a +#define GC_USB_GHWCFG4_INEPS_MASK 0x3c000000 +#define GC_USB_GHWCFG4_INEPS_SIZE 0x4 +#define GC_USB_GHWCFG4_INEPS_DEFAULT 0x0 +#define GC_USB_GHWCFG4_INEPS_OFFSET 0x50 +#define GC_USB_GHWCFG4_DESCDMAENABLED_LSB 0x1e +#define GC_USB_GHWCFG4_DESCDMAENABLED_MASK 0x40000000 +#define GC_USB_GHWCFG4_DESCDMAENABLED_SIZE 0x1 +#define GC_USB_GHWCFG4_DESCDMAENABLED_DEFAULT 0x0 +#define GC_USB_GHWCFG4_DESCDMAENABLED_OFFSET 0x50 +#define GC_USB_GHWCFG4_DESCDMA_LSB 0x1f +#define GC_USB_GHWCFG4_DESCDMA_MASK 0x80000000 +#define GC_USB_GHWCFG4_DESCDMA_SIZE 0x1 +#define GC_USB_GHWCFG4_DESCDMA_DEFAULT 0x0 +#define GC_USB_GHWCFG4_DESCDMA_OFFSET 0x50 +#define GC_USB_GDFIFOCFG_GDFIFOCFG_LSB 0x0 +#define GC_USB_GDFIFOCFG_GDFIFOCFG_MASK 0xffff +#define GC_USB_GDFIFOCFG_GDFIFOCFG_SIZE 0x10 +#define GC_USB_GDFIFOCFG_GDFIFOCFG_DEFAULT 0x0 +#define GC_USB_GDFIFOCFG_GDFIFOCFG_OFFSET 0x5c +#define GC_USB_GDFIFOCFG_EPINFOBASEADDR_LSB 0x10 +#define GC_USB_GDFIFOCFG_EPINFOBASEADDR_MASK 0xffff0000 +#define GC_USB_GDFIFOCFG_EPINFOBASEADDR_SIZE 0x10 +#define GC_USB_GDFIFOCFG_EPINFOBASEADDR_DEFAULT 0x0 +#define GC_USB_GDFIFOCFG_EPINFOBASEADDR_OFFSET 0x5c +#define GC_USB_DIEPTXF1_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF1_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF1_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF1_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF1_INEPNTXFSTADDR_OFFSET 0x104 +#define GC_USB_DIEPTXF1_RESERVED11_LSB 0xc +#define GC_USB_DIEPTXF1_RESERVED11_MASK 0x1000 +#define GC_USB_DIEPTXF1_RESERVED11_SIZE 0x1 +#define GC_USB_DIEPTXF1_RESERVED11_DEFAULT 0x1 +#define GC_USB_DIEPTXF1_RESERVED11_OFFSET 0x104 +#define GC_USB_DIEPTXF1_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF1_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF1_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF1_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF1_INEPNTXFDEP_OFFSET 0x104 +#define GC_USB_DIEPTXF2_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF2_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF2_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF2_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF2_INEPNTXFSTADDR_OFFSET 0x108 +#define GC_USB_DIEPTXF2_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF2_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF2_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF2_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF2_INEPNTXFDEP_OFFSET 0x108 +#define GC_USB_DIEPTXF3_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF3_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF3_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF3_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF3_INEPNTXFSTADDR_OFFSET 0x10c +#define GC_USB_DIEPTXF3_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF3_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF3_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF3_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF3_INEPNTXFDEP_OFFSET 0x10c +#define GC_USB_DIEPTXF4_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF4_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF4_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF4_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF4_INEPNTXFSTADDR_OFFSET 0x110 +#define GC_USB_DIEPTXF4_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF4_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF4_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF4_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF4_INEPNTXFDEP_OFFSET 0x110 +#define GC_USB_DIEPTXF5_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF5_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF5_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF5_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF5_INEPNTXFSTADDR_OFFSET 0x114 +#define GC_USB_DIEPTXF5_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF5_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF5_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF5_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF5_INEPNTXFDEP_OFFSET 0x114 +#define GC_USB_DIEPTXF6_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF6_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF6_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF6_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF6_INEPNTXFSTADDR_OFFSET 0x118 +#define GC_USB_DIEPTXF6_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF6_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF6_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF6_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF6_INEPNTXFDEP_OFFSET 0x118 +#define GC_USB_DIEPTXF7_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF7_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF7_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF7_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF7_INEPNTXFSTADDR_OFFSET 0x11c +#define GC_USB_DIEPTXF7_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF7_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF7_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF7_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF7_INEPNTXFDEP_OFFSET 0x11c +#define GC_USB_DIEPTXF8_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF8_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF8_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF8_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF8_INEPNTXFSTADDR_OFFSET 0x120 +#define GC_USB_DIEPTXF8_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF8_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF8_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF8_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF8_INEPNTXFDEP_OFFSET 0x120 +#define GC_USB_DIEPTXF9_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF9_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF9_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF9_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF9_INEPNTXFSTADDR_OFFSET 0x124 +#define GC_USB_DIEPTXF9_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF9_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF9_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF9_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF9_INEPNTXFDEP_OFFSET 0x124 +#define GC_USB_DIEPTXF10_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF10_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF10_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF10_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF10_INEPNTXFSTADDR_OFFSET 0x128 +#define GC_USB_DIEPTXF10_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF10_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF10_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF10_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF10_INEPNTXFDEP_OFFSET 0x128 +#define GC_USB_DIEPTXF11_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF11_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF11_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF11_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF11_INEPNTXFSTADDR_OFFSET 0x12c +#define GC_USB_DIEPTXF11_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF11_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF11_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF11_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF11_INEPNTXFDEP_OFFSET 0x12c +#define GC_USB_DIEPTXF12_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF12_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF12_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF12_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF12_INEPNTXFSTADDR_OFFSET 0x130 +#define GC_USB_DIEPTXF12_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF12_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF12_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF12_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF12_INEPNTXFDEP_OFFSET 0x130 +#define GC_USB_DIEPTXF13_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF13_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF13_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF13_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF13_INEPNTXFSTADDR_OFFSET 0x134 +#define GC_USB_DIEPTXF13_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF13_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF13_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF13_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF13_INEPNTXFDEP_OFFSET 0x134 +#define GC_USB_DIEPTXF14_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF14_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF14_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF14_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF14_INEPNTXFSTADDR_OFFSET 0x138 +#define GC_USB_DIEPTXF14_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF14_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF14_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF14_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF14_INEPNTXFDEP_OFFSET 0x138 +#define GC_USB_DIEPTXF15_INEPNTXFSTADDR_LSB 0x0 +#define GC_USB_DIEPTXF15_INEPNTXFSTADDR_MASK 0x7ff +#define GC_USB_DIEPTXF15_INEPNTXFSTADDR_SIZE 0xb +#define GC_USB_DIEPTXF15_INEPNTXFSTADDR_DEFAULT 0x0 +#define GC_USB_DIEPTXF15_INEPNTXFSTADDR_OFFSET 0x13c +#define GC_USB_DIEPTXF15_INEPNTXFDEP_LSB 0x10 +#define GC_USB_DIEPTXF15_INEPNTXFDEP_MASK 0x3f0000 +#define GC_USB_DIEPTXF15_INEPNTXFDEP_SIZE 0x6 +#define GC_USB_DIEPTXF15_INEPNTXFDEP_DEFAULT 0x0 +#define GC_USB_DIEPTXF15_INEPNTXFDEP_OFFSET 0x13c +#define GC_USB_DCFG_DEVSPD_LSB 0x0 +#define GC_USB_DCFG_DEVSPD_MASK 0x3 +#define GC_USB_DCFG_DEVSPD_SIZE 0x2 +#define GC_USB_DCFG_DEVSPD_DEFAULT 0x0 +#define GC_USB_DCFG_DEVSPD_OFFSET 0x800 +#define GC_USB_DCFG_NZSTSOUTHSHK_LSB 0x2 +#define GC_USB_DCFG_NZSTSOUTHSHK_MASK 0x4 +#define GC_USB_DCFG_NZSTSOUTHSHK_SIZE 0x1 +#define GC_USB_DCFG_NZSTSOUTHSHK_DEFAULT 0x0 +#define GC_USB_DCFG_NZSTSOUTHSHK_OFFSET 0x800 +#define GC_USB_DCFG_ENA32KHZSUSP_LSB 0x3 +#define GC_USB_DCFG_ENA32KHZSUSP_MASK 0x8 +#define GC_USB_DCFG_ENA32KHZSUSP_SIZE 0x1 +#define GC_USB_DCFG_ENA32KHZSUSP_DEFAULT 0x0 +#define GC_USB_DCFG_ENA32KHZSUSP_OFFSET 0x800 +#define GC_USB_DCFG_DEVADDR_LSB 0x4 +#define GC_USB_DCFG_DEVADDR_MASK 0x7f0 +#define GC_USB_DCFG_DEVADDR_SIZE 0x7 +#define GC_USB_DCFG_DEVADDR_DEFAULT 0x0 +#define GC_USB_DCFG_DEVADDR_OFFSET 0x800 +#define GC_USB_DCFG_PERFRINT_LSB 0xb +#define GC_USB_DCFG_PERFRINT_MASK 0x1800 +#define GC_USB_DCFG_PERFRINT_SIZE 0x2 +#define GC_USB_DCFG_PERFRINT_DEFAULT 0x0 +#define GC_USB_DCFG_PERFRINT_OFFSET 0x800 +#define GC_USB_DCFG_ENDEVOUTNAK_LSB 0xd +#define GC_USB_DCFG_ENDEVOUTNAK_MASK 0x2000 +#define GC_USB_DCFG_ENDEVOUTNAK_SIZE 0x1 +#define GC_USB_DCFG_ENDEVOUTNAK_DEFAULT 0x0 +#define GC_USB_DCFG_ENDEVOUTNAK_OFFSET 0x800 +#define GC_USB_DCFG_XCVRDLY_LSB 0xe +#define GC_USB_DCFG_XCVRDLY_MASK 0x4000 +#define GC_USB_DCFG_XCVRDLY_SIZE 0x1 +#define GC_USB_DCFG_XCVRDLY_DEFAULT 0x0 +#define GC_USB_DCFG_XCVRDLY_OFFSET 0x800 +#define GC_USB_DCFG_ERRATICINTMSK_LSB 0xf +#define GC_USB_DCFG_ERRATICINTMSK_MASK 0x8000 +#define GC_USB_DCFG_ERRATICINTMSK_SIZE 0x1 +#define GC_USB_DCFG_ERRATICINTMSK_DEFAULT 0x0 +#define GC_USB_DCFG_ERRATICINTMSK_OFFSET 0x800 +#define GC_USB_DCFG_DESCDMA_LSB 0x17 +#define GC_USB_DCFG_DESCDMA_MASK 0x800000 +#define GC_USB_DCFG_DESCDMA_SIZE 0x1 +#define GC_USB_DCFG_DESCDMA_DEFAULT 0x0 +#define GC_USB_DCFG_DESCDMA_OFFSET 0x800 +#define GC_USB_DCFG_PERSCHINTVL_LSB 0x18 +#define GC_USB_DCFG_PERSCHINTVL_MASK 0x3000000 +#define GC_USB_DCFG_PERSCHINTVL_SIZE 0x2 +#define GC_USB_DCFG_PERSCHINTVL_DEFAULT 0x0 +#define GC_USB_DCFG_PERSCHINTVL_OFFSET 0x800 +#define GC_USB_DCFG_RESVALID_LSB 0x1a +#define GC_USB_DCFG_RESVALID_MASK 0xfc000000 +#define GC_USB_DCFG_RESVALID_SIZE 0x6 +#define GC_USB_DCFG_RESVALID_DEFAULT 0x2 +#define GC_USB_DCFG_RESVALID_OFFSET 0x800 +#define GC_USB_DCTL_RMTWKUPSIG_LSB 0x0 +#define GC_USB_DCTL_RMTWKUPSIG_MASK 0x1 +#define GC_USB_DCTL_RMTWKUPSIG_SIZE 0x1 +#define GC_USB_DCTL_RMTWKUPSIG_DEFAULT 0x0 +#define GC_USB_DCTL_RMTWKUPSIG_OFFSET 0x804 +#define GC_USB_DCTL_SFTDISCON_LSB 0x1 +#define GC_USB_DCTL_SFTDISCON_MASK 0x2 +#define GC_USB_DCTL_SFTDISCON_SIZE 0x1 +#define GC_USB_DCTL_SFTDISCON_DEFAULT 0x0 +#define GC_USB_DCTL_SFTDISCON_OFFSET 0x804 +#define GC_USB_DCTL_GNPINNAKSTS_LSB 0x2 +#define GC_USB_DCTL_GNPINNAKSTS_MASK 0x4 +#define GC_USB_DCTL_GNPINNAKSTS_SIZE 0x1 +#define GC_USB_DCTL_GNPINNAKSTS_DEFAULT 0x0 +#define GC_USB_DCTL_GNPINNAKSTS_OFFSET 0x804 +#define GC_USB_DCTL_GOUTNAKSTS_LSB 0x3 +#define GC_USB_DCTL_GOUTNAKSTS_MASK 0x8 +#define GC_USB_DCTL_GOUTNAKSTS_SIZE 0x1 +#define GC_USB_DCTL_GOUTNAKSTS_DEFAULT 0x0 +#define GC_USB_DCTL_GOUTNAKSTS_OFFSET 0x804 +#define GC_USB_DCTL_TSTCTL_LSB 0x4 +#define GC_USB_DCTL_TSTCTL_MASK 0x70 +#define GC_USB_DCTL_TSTCTL_SIZE 0x3 +#define GC_USB_DCTL_TSTCTL_DEFAULT 0x0 +#define GC_USB_DCTL_TSTCTL_OFFSET 0x804 +#define GC_USB_DCTL_SGNPINNAK_LSB 0x7 +#define GC_USB_DCTL_SGNPINNAK_MASK 0x80 +#define GC_USB_DCTL_SGNPINNAK_SIZE 0x1 +#define GC_USB_DCTL_SGNPINNAK_DEFAULT 0x0 +#define GC_USB_DCTL_SGNPINNAK_OFFSET 0x804 +#define GC_USB_DCTL_CGNPINNAK_LSB 0x8 +#define GC_USB_DCTL_CGNPINNAK_MASK 0x100 +#define GC_USB_DCTL_CGNPINNAK_SIZE 0x1 +#define GC_USB_DCTL_CGNPINNAK_DEFAULT 0x0 +#define GC_USB_DCTL_CGNPINNAK_OFFSET 0x804 +#define GC_USB_DCTL_SGOUTNAK_LSB 0x9 +#define GC_USB_DCTL_SGOUTNAK_MASK 0x200 +#define GC_USB_DCTL_SGOUTNAK_SIZE 0x1 +#define GC_USB_DCTL_SGOUTNAK_DEFAULT 0x0 +#define GC_USB_DCTL_SGOUTNAK_OFFSET 0x804 +#define GC_USB_DCTL_CGOUTNAK_LSB 0xa +#define GC_USB_DCTL_CGOUTNAK_MASK 0x400 +#define GC_USB_DCTL_CGOUTNAK_SIZE 0x1 +#define GC_USB_DCTL_CGOUTNAK_DEFAULT 0x0 +#define GC_USB_DCTL_CGOUTNAK_OFFSET 0x804 +#define GC_USB_DCTL_PWRONPRGDONE_LSB 0xb +#define GC_USB_DCTL_PWRONPRGDONE_MASK 0x800 +#define GC_USB_DCTL_PWRONPRGDONE_SIZE 0x1 +#define GC_USB_DCTL_PWRONPRGDONE_DEFAULT 0x0 +#define GC_USB_DCTL_PWRONPRGDONE_OFFSET 0x804 +#define GC_USB_DCTL_GMC_LSB 0xd +#define GC_USB_DCTL_GMC_MASK 0x6000 +#define GC_USB_DCTL_GMC_SIZE 0x2 +#define GC_USB_DCTL_GMC_DEFAULT 0x0 +#define GC_USB_DCTL_GMC_OFFSET 0x804 +#define GC_USB_DCTL_IGNRFRMNUM_LSB 0xf +#define GC_USB_DCTL_IGNRFRMNUM_MASK 0x8000 +#define GC_USB_DCTL_IGNRFRMNUM_SIZE 0x1 +#define GC_USB_DCTL_IGNRFRMNUM_DEFAULT 0x0 +#define GC_USB_DCTL_IGNRFRMNUM_OFFSET 0x804 +#define GC_USB_DCTL_NAKONBBLE_LSB 0x10 +#define GC_USB_DCTL_NAKONBBLE_MASK 0x10000 +#define GC_USB_DCTL_NAKONBBLE_SIZE 0x1 +#define GC_USB_DCTL_NAKONBBLE_DEFAULT 0x0 +#define GC_USB_DCTL_NAKONBBLE_OFFSET 0x804 +#define GC_USB_DCTL_ENCONTONBNA_LSB 0x11 +#define GC_USB_DCTL_ENCONTONBNA_MASK 0x20000 +#define GC_USB_DCTL_ENCONTONBNA_SIZE 0x1 +#define GC_USB_DCTL_ENCONTONBNA_DEFAULT 0x0 +#define GC_USB_DCTL_ENCONTONBNA_OFFSET 0x804 +#define GC_USB_DSTS_SUSPSTS_LSB 0x0 +#define GC_USB_DSTS_SUSPSTS_MASK 0x1 +#define GC_USB_DSTS_SUSPSTS_SIZE 0x1 +#define GC_USB_DSTS_SUSPSTS_DEFAULT 0x0 +#define GC_USB_DSTS_SUSPSTS_OFFSET 0x808 +#define GC_USB_DSTS_ENUMSPD_LSB 0x1 +#define GC_USB_DSTS_ENUMSPD_MASK 0x6 +#define GC_USB_DSTS_ENUMSPD_SIZE 0x2 +#define GC_USB_DSTS_ENUMSPD_DEFAULT 0x0 +#define GC_USB_DSTS_ENUMSPD_OFFSET 0x808 +#define GC_USB_DSTS_ERRTICERR_LSB 0x3 +#define GC_USB_DSTS_ERRTICERR_MASK 0x8 +#define GC_USB_DSTS_ERRTICERR_SIZE 0x1 +#define GC_USB_DSTS_ERRTICERR_DEFAULT 0x0 +#define GC_USB_DSTS_ERRTICERR_OFFSET 0x808 +#define GC_USB_DSTS_SOFFN_LSB 0x8 +#define GC_USB_DSTS_SOFFN_MASK 0x3fff00 +#define GC_USB_DSTS_SOFFN_SIZE 0xe +#define GC_USB_DSTS_SOFFN_DEFAULT 0x0 +#define GC_USB_DSTS_SOFFN_OFFSET 0x808 +#define GC_USB_DSTS_DEVLNSTS_LSB 0x16 +#define GC_USB_DSTS_DEVLNSTS_MASK 0xc00000 +#define GC_USB_DSTS_DEVLNSTS_SIZE 0x2 +#define GC_USB_DSTS_DEVLNSTS_DEFAULT 0x0 +#define GC_USB_DSTS_DEVLNSTS_OFFSET 0x808 +#define GC_USB_DIEPMSK_XFERCOMPLMSK_LSB 0x0 +#define GC_USB_DIEPMSK_XFERCOMPLMSK_MASK 0x1 +#define GC_USB_DIEPMSK_XFERCOMPLMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_XFERCOMPLMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_XFERCOMPLMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_EPDISBLDMSK_LSB 0x1 +#define GC_USB_DIEPMSK_EPDISBLDMSK_MASK 0x2 +#define GC_USB_DIEPMSK_EPDISBLDMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_EPDISBLDMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_EPDISBLDMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_AHBERRMSK_LSB 0x2 +#define GC_USB_DIEPMSK_AHBERRMSK_MASK 0x4 +#define GC_USB_DIEPMSK_AHBERRMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_AHBERRMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_AHBERRMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_TIMEOUTMSK_LSB 0x3 +#define GC_USB_DIEPMSK_TIMEOUTMSK_MASK 0x8 +#define GC_USB_DIEPMSK_TIMEOUTMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_TIMEOUTMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_TIMEOUTMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_INTKNTXFEMPMSK_LSB 0x4 +#define GC_USB_DIEPMSK_INTKNTXFEMPMSK_MASK 0x10 +#define GC_USB_DIEPMSK_INTKNTXFEMPMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_INTKNTXFEMPMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_INTKNTXFEMPMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_INTKNEPMISMSK_LSB 0x5 +#define GC_USB_DIEPMSK_INTKNEPMISMSK_MASK 0x20 +#define GC_USB_DIEPMSK_INTKNEPMISMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_INTKNEPMISMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_INTKNEPMISMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_INEPNAKEFFMSK_LSB 0x6 +#define GC_USB_DIEPMSK_INEPNAKEFFMSK_MASK 0x40 +#define GC_USB_DIEPMSK_INEPNAKEFFMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_INEPNAKEFFMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_INEPNAKEFFMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_RESERVED7_LSB 0x7 +#define GC_USB_DIEPMSK_RESERVED7_MASK 0x80 +#define GC_USB_DIEPMSK_RESERVED7_SIZE 0x1 +#define GC_USB_DIEPMSK_RESERVED7_DEFAULT 0x1 +#define GC_USB_DIEPMSK_RESERVED7_OFFSET 0x810 +#define GC_USB_DIEPMSK_TXFIFOUNDRNMSK_LSB 0x8 +#define GC_USB_DIEPMSK_TXFIFOUNDRNMSK_MASK 0x100 +#define GC_USB_DIEPMSK_TXFIFOUNDRNMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_TXFIFOUNDRNMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_TXFIFOUNDRNMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_BNAININTRMSK_LSB 0x9 +#define GC_USB_DIEPMSK_BNAININTRMSK_MASK 0x200 +#define GC_USB_DIEPMSK_BNAININTRMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_BNAININTRMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_BNAININTRMSK_OFFSET 0x810 +#define GC_USB_DIEPMSK_NAKMSK_LSB 0xd +#define GC_USB_DIEPMSK_NAKMSK_MASK 0x2000 +#define GC_USB_DIEPMSK_NAKMSK_SIZE 0x1 +#define GC_USB_DIEPMSK_NAKMSK_DEFAULT 0x0 +#define GC_USB_DIEPMSK_NAKMSK_OFFSET 0x810 +#define GC_USB_DOEPMSK_XFERCOMPLMSK_LSB 0x0 +#define GC_USB_DOEPMSK_XFERCOMPLMSK_MASK 0x1 +#define GC_USB_DOEPMSK_XFERCOMPLMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_XFERCOMPLMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_XFERCOMPLMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_EPDISBLDMSK_LSB 0x1 +#define GC_USB_DOEPMSK_EPDISBLDMSK_MASK 0x2 +#define GC_USB_DOEPMSK_EPDISBLDMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_EPDISBLDMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_EPDISBLDMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_AHBERRMSK_LSB 0x2 +#define GC_USB_DOEPMSK_AHBERRMSK_MASK 0x4 +#define GC_USB_DOEPMSK_AHBERRMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_AHBERRMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_AHBERRMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_SETUPMSK_LSB 0x3 +#define GC_USB_DOEPMSK_SETUPMSK_MASK 0x8 +#define GC_USB_DOEPMSK_SETUPMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_SETUPMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_SETUPMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_OUTTKNEPDISMSK_LSB 0x4 +#define GC_USB_DOEPMSK_OUTTKNEPDISMSK_MASK 0x10 +#define GC_USB_DOEPMSK_OUTTKNEPDISMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_OUTTKNEPDISMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_OUTTKNEPDISMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_STSPHSERCVDMSK_LSB 0x5 +#define GC_USB_DOEPMSK_STSPHSERCVDMSK_MASK 0x20 +#define GC_USB_DOEPMSK_STSPHSERCVDMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_STSPHSERCVDMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_STSPHSERCVDMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPMSK_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPMSK_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPMSK_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPMSK_BACK2BACKSETUP_OFFSET 0x814 +#define GC_USB_DOEPMSK_OUTPKTERRMSK_LSB 0x8 +#define GC_USB_DOEPMSK_OUTPKTERRMSK_MASK 0x100 +#define GC_USB_DOEPMSK_OUTPKTERRMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_OUTPKTERRMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_OUTPKTERRMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_BNAOUTINTRMSK_LSB 0x9 +#define GC_USB_DOEPMSK_BNAOUTINTRMSK_MASK 0x200 +#define GC_USB_DOEPMSK_BNAOUTINTRMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_BNAOUTINTRMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_BNAOUTINTRMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_BBLEERRMSK_LSB 0xc +#define GC_USB_DOEPMSK_BBLEERRMSK_MASK 0x1000 +#define GC_USB_DOEPMSK_BBLEERRMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_BBLEERRMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_BBLEERRMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_NAKMSK_LSB 0xd +#define GC_USB_DOEPMSK_NAKMSK_MASK 0x2000 +#define GC_USB_DOEPMSK_NAKMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_NAKMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_NAKMSK_OFFSET 0x814 +#define GC_USB_DOEPMSK_NYETMSK_LSB 0xe +#define GC_USB_DOEPMSK_NYETMSK_MASK 0x4000 +#define GC_USB_DOEPMSK_NYETMSK_SIZE 0x1 +#define GC_USB_DOEPMSK_NYETMSK_DEFAULT 0x0 +#define GC_USB_DOEPMSK_NYETMSK_OFFSET 0x814 +#define GC_USB_DAINT_INEPINT0_LSB 0x0 +#define GC_USB_DAINT_INEPINT0_MASK 0x1 +#define GC_USB_DAINT_INEPINT0_SIZE 0x1 +#define GC_USB_DAINT_INEPINT0_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT0_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT1_LSB 0x1 +#define GC_USB_DAINT_INEPINT1_MASK 0x2 +#define GC_USB_DAINT_INEPINT1_SIZE 0x1 +#define GC_USB_DAINT_INEPINT1_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT1_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT2_LSB 0x2 +#define GC_USB_DAINT_INEPINT2_MASK 0x4 +#define GC_USB_DAINT_INEPINT2_SIZE 0x1 +#define GC_USB_DAINT_INEPINT2_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT2_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT3_LSB 0x3 +#define GC_USB_DAINT_INEPINT3_MASK 0x8 +#define GC_USB_DAINT_INEPINT3_SIZE 0x1 +#define GC_USB_DAINT_INEPINT3_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT3_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT4_LSB 0x4 +#define GC_USB_DAINT_INEPINT4_MASK 0x10 +#define GC_USB_DAINT_INEPINT4_SIZE 0x1 +#define GC_USB_DAINT_INEPINT4_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT4_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT5_LSB 0x5 +#define GC_USB_DAINT_INEPINT5_MASK 0x20 +#define GC_USB_DAINT_INEPINT5_SIZE 0x1 +#define GC_USB_DAINT_INEPINT5_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT5_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT6_LSB 0x6 +#define GC_USB_DAINT_INEPINT6_MASK 0x40 +#define GC_USB_DAINT_INEPINT6_SIZE 0x1 +#define GC_USB_DAINT_INEPINT6_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT6_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT7_LSB 0x7 +#define GC_USB_DAINT_INEPINT7_MASK 0x80 +#define GC_USB_DAINT_INEPINT7_SIZE 0x1 +#define GC_USB_DAINT_INEPINT7_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT7_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT8_LSB 0x8 +#define GC_USB_DAINT_INEPINT8_MASK 0x100 +#define GC_USB_DAINT_INEPINT8_SIZE 0x1 +#define GC_USB_DAINT_INEPINT8_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT8_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT9_LSB 0x9 +#define GC_USB_DAINT_INEPINT9_MASK 0x200 +#define GC_USB_DAINT_INEPINT9_SIZE 0x1 +#define GC_USB_DAINT_INEPINT9_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT9_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT10_LSB 0xa +#define GC_USB_DAINT_INEPINT10_MASK 0x400 +#define GC_USB_DAINT_INEPINT10_SIZE 0x1 +#define GC_USB_DAINT_INEPINT10_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT10_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT11_LSB 0xb +#define GC_USB_DAINT_INEPINT11_MASK 0x800 +#define GC_USB_DAINT_INEPINT11_SIZE 0x1 +#define GC_USB_DAINT_INEPINT11_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT11_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT12_LSB 0xc +#define GC_USB_DAINT_INEPINT12_MASK 0x1000 +#define GC_USB_DAINT_INEPINT12_SIZE 0x1 +#define GC_USB_DAINT_INEPINT12_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT12_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT13_LSB 0xd +#define GC_USB_DAINT_INEPINT13_MASK 0x2000 +#define GC_USB_DAINT_INEPINT13_SIZE 0x1 +#define GC_USB_DAINT_INEPINT13_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT13_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT14_LSB 0xe +#define GC_USB_DAINT_INEPINT14_MASK 0x4000 +#define GC_USB_DAINT_INEPINT14_SIZE 0x1 +#define GC_USB_DAINT_INEPINT14_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT14_OFFSET 0x818 +#define GC_USB_DAINT_INEPINT15_LSB 0xf +#define GC_USB_DAINT_INEPINT15_MASK 0x8000 +#define GC_USB_DAINT_INEPINT15_SIZE 0x1 +#define GC_USB_DAINT_INEPINT15_DEFAULT 0x0 +#define GC_USB_DAINT_INEPINT15_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT0_LSB 0x10 +#define GC_USB_DAINT_OUTEPINT0_MASK 0x10000 +#define GC_USB_DAINT_OUTEPINT0_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT0_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT0_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT1_LSB 0x11 +#define GC_USB_DAINT_OUTEPINT1_MASK 0x20000 +#define GC_USB_DAINT_OUTEPINT1_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT1_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT1_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT2_LSB 0x12 +#define GC_USB_DAINT_OUTEPINT2_MASK 0x40000 +#define GC_USB_DAINT_OUTEPINT2_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT2_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT2_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT3_LSB 0x13 +#define GC_USB_DAINT_OUTEPINT3_MASK 0x80000 +#define GC_USB_DAINT_OUTEPINT3_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT3_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT3_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT4_LSB 0x14 +#define GC_USB_DAINT_OUTEPINT4_MASK 0x100000 +#define GC_USB_DAINT_OUTEPINT4_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT4_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT4_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT5_LSB 0x15 +#define GC_USB_DAINT_OUTEPINT5_MASK 0x200000 +#define GC_USB_DAINT_OUTEPINT5_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT5_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT5_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT6_LSB 0x16 +#define GC_USB_DAINT_OUTEPINT6_MASK 0x400000 +#define GC_USB_DAINT_OUTEPINT6_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT6_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT6_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT7_LSB 0x17 +#define GC_USB_DAINT_OUTEPINT7_MASK 0x800000 +#define GC_USB_DAINT_OUTEPINT7_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT7_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT7_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT8_LSB 0x18 +#define GC_USB_DAINT_OUTEPINT8_MASK 0x1000000 +#define GC_USB_DAINT_OUTEPINT8_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT8_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT8_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT9_LSB 0x19 +#define GC_USB_DAINT_OUTEPINT9_MASK 0x2000000 +#define GC_USB_DAINT_OUTEPINT9_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT9_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT9_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT10_LSB 0x1a +#define GC_USB_DAINT_OUTEPINT10_MASK 0x4000000 +#define GC_USB_DAINT_OUTEPINT10_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT10_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT10_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT11_LSB 0x1b +#define GC_USB_DAINT_OUTEPINT11_MASK 0x8000000 +#define GC_USB_DAINT_OUTEPINT11_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT11_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT11_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT12_LSB 0x1c +#define GC_USB_DAINT_OUTEPINT12_MASK 0x10000000 +#define GC_USB_DAINT_OUTEPINT12_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT12_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT12_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT13_LSB 0x1d +#define GC_USB_DAINT_OUTEPINT13_MASK 0x20000000 +#define GC_USB_DAINT_OUTEPINT13_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT13_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT13_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT14_LSB 0x1e +#define GC_USB_DAINT_OUTEPINT14_MASK 0x40000000 +#define GC_USB_DAINT_OUTEPINT14_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT14_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT14_OFFSET 0x818 +#define GC_USB_DAINT_OUTEPINT15_LSB 0x1f +#define GC_USB_DAINT_OUTEPINT15_MASK 0x80000000 +#define GC_USB_DAINT_OUTEPINT15_SIZE 0x1 +#define GC_USB_DAINT_OUTEPINT15_DEFAULT 0x0 +#define GC_USB_DAINT_OUTEPINT15_OFFSET 0x818 +#define GC_USB_DAINTMSK_INEPMSK0_LSB 0x0 +#define GC_USB_DAINTMSK_INEPMSK0_MASK 0x1 +#define GC_USB_DAINTMSK_INEPMSK0_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK0_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK0_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK1_LSB 0x1 +#define GC_USB_DAINTMSK_INEPMSK1_MASK 0x2 +#define GC_USB_DAINTMSK_INEPMSK1_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK1_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK1_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK2_LSB 0x2 +#define GC_USB_DAINTMSK_INEPMSK2_MASK 0x4 +#define GC_USB_DAINTMSK_INEPMSK2_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK2_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK2_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK3_LSB 0x3 +#define GC_USB_DAINTMSK_INEPMSK3_MASK 0x8 +#define GC_USB_DAINTMSK_INEPMSK3_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK3_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK3_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK4_LSB 0x4 +#define GC_USB_DAINTMSK_INEPMSK4_MASK 0x10 +#define GC_USB_DAINTMSK_INEPMSK4_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK4_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK4_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK5_LSB 0x5 +#define GC_USB_DAINTMSK_INEPMSK5_MASK 0x20 +#define GC_USB_DAINTMSK_INEPMSK5_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK5_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK5_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK6_LSB 0x6 +#define GC_USB_DAINTMSK_INEPMSK6_MASK 0x40 +#define GC_USB_DAINTMSK_INEPMSK6_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK6_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK6_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK7_LSB 0x7 +#define GC_USB_DAINTMSK_INEPMSK7_MASK 0x80 +#define GC_USB_DAINTMSK_INEPMSK7_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK7_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK7_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK8_LSB 0x8 +#define GC_USB_DAINTMSK_INEPMSK8_MASK 0x100 +#define GC_USB_DAINTMSK_INEPMSK8_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK8_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK8_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK9_LSB 0x9 +#define GC_USB_DAINTMSK_INEPMSK9_MASK 0x200 +#define GC_USB_DAINTMSK_INEPMSK9_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK9_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK9_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK10_LSB 0xa +#define GC_USB_DAINTMSK_INEPMSK10_MASK 0x400 +#define GC_USB_DAINTMSK_INEPMSK10_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK10_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK10_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK11_LSB 0xb +#define GC_USB_DAINTMSK_INEPMSK11_MASK 0x800 +#define GC_USB_DAINTMSK_INEPMSK11_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK11_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK11_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK12_LSB 0xc +#define GC_USB_DAINTMSK_INEPMSK12_MASK 0x1000 +#define GC_USB_DAINTMSK_INEPMSK12_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK12_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK12_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK13_LSB 0xd +#define GC_USB_DAINTMSK_INEPMSK13_MASK 0x2000 +#define GC_USB_DAINTMSK_INEPMSK13_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK13_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK13_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK14_LSB 0xe +#define GC_USB_DAINTMSK_INEPMSK14_MASK 0x4000 +#define GC_USB_DAINTMSK_INEPMSK14_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK14_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK14_OFFSET 0x81c +#define GC_USB_DAINTMSK_INEPMSK15_LSB 0xf +#define GC_USB_DAINTMSK_INEPMSK15_MASK 0x8000 +#define GC_USB_DAINTMSK_INEPMSK15_SIZE 0x1 +#define GC_USB_DAINTMSK_INEPMSK15_DEFAULT 0x0 +#define GC_USB_DAINTMSK_INEPMSK15_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK0_LSB 0x10 +#define GC_USB_DAINTMSK_OUTEPMSK0_MASK 0x10000 +#define GC_USB_DAINTMSK_OUTEPMSK0_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK0_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK0_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK1_LSB 0x11 +#define GC_USB_DAINTMSK_OUTEPMSK1_MASK 0x20000 +#define GC_USB_DAINTMSK_OUTEPMSK1_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK1_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK1_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK2_LSB 0x12 +#define GC_USB_DAINTMSK_OUTEPMSK2_MASK 0x40000 +#define GC_USB_DAINTMSK_OUTEPMSK2_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK2_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK2_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK3_LSB 0x13 +#define GC_USB_DAINTMSK_OUTEPMSK3_MASK 0x80000 +#define GC_USB_DAINTMSK_OUTEPMSK3_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK3_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK3_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK4_LSB 0x14 +#define GC_USB_DAINTMSK_OUTEPMSK4_MASK 0x100000 +#define GC_USB_DAINTMSK_OUTEPMSK4_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK4_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK4_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK5_LSB 0x15 +#define GC_USB_DAINTMSK_OUTEPMSK5_MASK 0x200000 +#define GC_USB_DAINTMSK_OUTEPMSK5_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK5_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK5_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK6_LSB 0x16 +#define GC_USB_DAINTMSK_OUTEPMSK6_MASK 0x400000 +#define GC_USB_DAINTMSK_OUTEPMSK6_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK6_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK6_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK7_LSB 0x17 +#define GC_USB_DAINTMSK_OUTEPMSK7_MASK 0x800000 +#define GC_USB_DAINTMSK_OUTEPMSK7_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK7_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK7_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK8_LSB 0x18 +#define GC_USB_DAINTMSK_OUTEPMSK8_MASK 0x1000000 +#define GC_USB_DAINTMSK_OUTEPMSK8_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK8_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK8_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK9_LSB 0x19 +#define GC_USB_DAINTMSK_OUTEPMSK9_MASK 0x2000000 +#define GC_USB_DAINTMSK_OUTEPMSK9_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK9_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK9_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK10_LSB 0x1a +#define GC_USB_DAINTMSK_OUTEPMSK10_MASK 0x4000000 +#define GC_USB_DAINTMSK_OUTEPMSK10_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK10_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK10_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK11_LSB 0x1b +#define GC_USB_DAINTMSK_OUTEPMSK11_MASK 0x8000000 +#define GC_USB_DAINTMSK_OUTEPMSK11_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK11_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK11_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK12_LSB 0x1c +#define GC_USB_DAINTMSK_OUTEPMSK12_MASK 0x10000000 +#define GC_USB_DAINTMSK_OUTEPMSK12_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK12_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK12_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK13_LSB 0x1d +#define GC_USB_DAINTMSK_OUTEPMSK13_MASK 0x20000000 +#define GC_USB_DAINTMSK_OUTEPMSK13_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK13_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK13_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK14_LSB 0x1e +#define GC_USB_DAINTMSK_OUTEPMSK14_MASK 0x40000000 +#define GC_USB_DAINTMSK_OUTEPMSK14_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK14_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK14_OFFSET 0x81c +#define GC_USB_DAINTMSK_OUTEPMSK15_LSB 0x1f +#define GC_USB_DAINTMSK_OUTEPMSK15_MASK 0x80000000 +#define GC_USB_DAINTMSK_OUTEPMSK15_SIZE 0x1 +#define GC_USB_DAINTMSK_OUTEPMSK15_DEFAULT 0x0 +#define GC_USB_DAINTMSK_OUTEPMSK15_OFFSET 0x81c +#define GC_USB_DVBUSDIS_DVBUSDIS_LSB 0x0 +#define GC_USB_DVBUSDIS_DVBUSDIS_MASK 0xffff +#define GC_USB_DVBUSDIS_DVBUSDIS_SIZE 0x10 +#define GC_USB_DVBUSDIS_DVBUSDIS_DEFAULT 0x0 +#define GC_USB_DVBUSDIS_DVBUSDIS_OFFSET 0x828 +#define GC_USB_DVBUSPULSE_DVBUSPULSE_LSB 0x0 +#define GC_USB_DVBUSPULSE_DVBUSPULSE_MASK 0xfff +#define GC_USB_DVBUSPULSE_DVBUSPULSE_SIZE 0xc +#define GC_USB_DVBUSPULSE_DVBUSPULSE_DEFAULT 0x0 +#define GC_USB_DVBUSPULSE_DVBUSPULSE_OFFSET 0x82c +#define GC_USB_DTHRCTL_NONISOTHREN_LSB 0x0 +#define GC_USB_DTHRCTL_NONISOTHREN_MASK 0x1 +#define GC_USB_DTHRCTL_NONISOTHREN_SIZE 0x1 +#define GC_USB_DTHRCTL_NONISOTHREN_DEFAULT 0x0 +#define GC_USB_DTHRCTL_NONISOTHREN_OFFSET 0x830 +#define GC_USB_DTHRCTL_ISOTHREN_LSB 0x1 +#define GC_USB_DTHRCTL_ISOTHREN_MASK 0x2 +#define GC_USB_DTHRCTL_ISOTHREN_SIZE 0x1 +#define GC_USB_DTHRCTL_ISOTHREN_DEFAULT 0x0 +#define GC_USB_DTHRCTL_ISOTHREN_OFFSET 0x830 +#define GC_USB_DTHRCTL_TXTHRLEN_LSB 0x2 +#define GC_USB_DTHRCTL_TXTHRLEN_MASK 0x7fc +#define GC_USB_DTHRCTL_TXTHRLEN_SIZE 0x9 +#define GC_USB_DTHRCTL_TXTHRLEN_DEFAULT 0x0 +#define GC_USB_DTHRCTL_TXTHRLEN_OFFSET 0x830 +#define GC_USB_DTHRCTL_AHBTHRRATIO_LSB 0xb +#define GC_USB_DTHRCTL_AHBTHRRATIO_MASK 0x1800 +#define GC_USB_DTHRCTL_AHBTHRRATIO_SIZE 0x2 +#define GC_USB_DTHRCTL_AHBTHRRATIO_DEFAULT 0x0 +#define GC_USB_DTHRCTL_AHBTHRRATIO_OFFSET 0x830 +#define GC_USB_DTHRCTL_RXTHREN_LSB 0x10 +#define GC_USB_DTHRCTL_RXTHREN_MASK 0x10000 +#define GC_USB_DTHRCTL_RXTHREN_SIZE 0x1 +#define GC_USB_DTHRCTL_RXTHREN_DEFAULT 0x0 +#define GC_USB_DTHRCTL_RXTHREN_OFFSET 0x830 +#define GC_USB_DTHRCTL_RXTHRLEN_LSB 0x11 +#define GC_USB_DTHRCTL_RXTHRLEN_MASK 0x3fe0000 +#define GC_USB_DTHRCTL_RXTHRLEN_SIZE 0x9 +#define GC_USB_DTHRCTL_RXTHRLEN_DEFAULT 0x0 +#define GC_USB_DTHRCTL_RXTHRLEN_OFFSET 0x830 +#define GC_USB_DTHRCTL_ARBPRKEN_LSB 0x1b +#define GC_USB_DTHRCTL_ARBPRKEN_MASK 0x8000000 +#define GC_USB_DTHRCTL_ARBPRKEN_SIZE 0x1 +#define GC_USB_DTHRCTL_ARBPRKEN_DEFAULT 0x0 +#define GC_USB_DTHRCTL_ARBPRKEN_OFFSET 0x830 +#define GC_USB_DIEPEMPMSK_INEPTXFEMPMSK_LSB 0x0 +#define GC_USB_DIEPEMPMSK_INEPTXFEMPMSK_MASK 0xffff +#define GC_USB_DIEPEMPMSK_INEPTXFEMPMSK_SIZE 0x10 +#define GC_USB_DIEPEMPMSK_INEPTXFEMPMSK_DEFAULT 0x0 +#define GC_USB_DIEPEMPMSK_INEPTXFEMPMSK_OFFSET 0x834 +#define GC_USB_DIEPCTL0_MPS_LSB 0x0 +#define GC_USB_DIEPCTL0_MPS_MASK 0x3 +#define GC_USB_DIEPCTL0_MPS_SIZE 0x2 +#define GC_USB_DIEPCTL0_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_MPS_OFFSET 0x900 +#define GC_USB_DIEPCTL0_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL0_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL0_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL0_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_USBACTEP_OFFSET 0x900 +#define GC_USB_DIEPCTL0_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL0_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL0_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL0_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_NAKSTS_OFFSET 0x900 +#define GC_USB_DIEPCTL0_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL0_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL0_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL0_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_EPTYPE_OFFSET 0x900 +#define GC_USB_DIEPCTL0_STALL_LSB 0x15 +#define GC_USB_DIEPCTL0_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL0_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL0_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_STALL_OFFSET 0x900 +#define GC_USB_DIEPCTL0_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL0_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL0_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL0_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_TXFNUM_OFFSET 0x900 +#define GC_USB_DIEPCTL0_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL0_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL0_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL0_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_CNAK_OFFSET 0x900 +#define GC_USB_DIEPCTL0_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL0_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL0_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL0_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_SNAK_OFFSET 0x900 +#define GC_USB_DIEPCTL0_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL0_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL0_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL0_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_EPDIS_OFFSET 0x900 +#define GC_USB_DIEPCTL0_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL0_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL0_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL0_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL0_EPENA_OFFSET 0x900 +#define GC_USB_DIEPINT0_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT0_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT0_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT0_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT0_XFERCOMPL_OFFSET 0x908 +#define GC_USB_DIEPINT0_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT0_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT0_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT0_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT0_EPDISBLD_OFFSET 0x908 +#define GC_USB_DIEPINT0_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT0_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT0_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT0_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT0_AHBERR_OFFSET 0x908 +#define GC_USB_DIEPINT0_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT0_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT0_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT0_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT0_TIMEOUT_OFFSET 0x908 +#define GC_USB_DIEPINT0_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT0_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT0_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT0_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT0_INTKNTXFEMP_OFFSET 0x908 +#define GC_USB_DIEPINT0_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT0_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT0_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT0_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT0_INTKNEPMIS_OFFSET 0x908 +#define GC_USB_DIEPINT0_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT0_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT0_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT0_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT0_INEPNAKEFF_OFFSET 0x908 +#define GC_USB_DIEPINT0_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT0_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT0_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT0_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT0_TXFEMP_OFFSET 0x908 +#define GC_USB_DIEPINT0_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT0_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT0_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT0_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT0_TXFIFOUNDRN_OFFSET 0x908 +#define GC_USB_DIEPINT0_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT0_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT0_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT0_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT0_BNAINTR_OFFSET 0x908 +#define GC_USB_DIEPINT0_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT0_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT0_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT0_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT0_PKTDRPSTS_OFFSET 0x908 +#define GC_USB_DIEPINT0_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT0_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT0_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT0_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT0_BBLEERR_OFFSET 0x908 +#define GC_USB_DIEPINT0_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT0_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT0_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT0_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT0_NAKINTRPT_OFFSET 0x908 +#define GC_USB_DIEPINT0_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT0_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT0_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT0_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT0_NYETINTRPT_OFFSET 0x908 +#define GC_USB_DIEPTSIZ0_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ0_XFERSIZE_MASK 0x7f +#define GC_USB_DIEPTSIZ0_XFERSIZE_SIZE 0x7 +#define GC_USB_DIEPTSIZ0_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ0_XFERSIZE_OFFSET 0x910 +#define GC_USB_DIEPTSIZ0_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ0_PKTCNT_MASK 0x180000 +#define GC_USB_DIEPTSIZ0_PKTCNT_SIZE 0x2 +#define GC_USB_DIEPTSIZ0_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ0_PKTCNT_OFFSET 0x910 +#define GC_USB_DIEPDMA0_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA0_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA0_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA0_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA0_DMAADDR_OFFSET 0x914 +#define GC_USB_DTXFSTS0_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS0_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS0_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS0_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS0_INEPTXFSPCAVAIL_OFFSET 0x918 +#define GC_USB_DIEPDMAB0_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB0_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB0_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB0_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB0_DMABUFFERADDR_OFFSET 0x91c +#define GC_USB_DIEPCTL1_MPS_LSB 0x0 +#define GC_USB_DIEPCTL1_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL1_MPS_SIZE 0xb +#define GC_USB_DIEPCTL1_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_MPS_OFFSET 0x920 +#define GC_USB_DIEPCTL1_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL1_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL1_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL1_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_USBACTEP_OFFSET 0x920 +#define GC_USB_DIEPCTL1_DPID_LSB 0x10 +#define GC_USB_DIEPCTL1_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL1_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL1_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_DPID_OFFSET 0x920 +#define GC_USB_DIEPCTL1_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL1_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL1_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL1_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_NAKSTS_OFFSET 0x920 +#define GC_USB_DIEPCTL1_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL1_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL1_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL1_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_EPTYPE_OFFSET 0x920 +#define GC_USB_DIEPCTL1_STALL_LSB 0x15 +#define GC_USB_DIEPCTL1_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL1_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL1_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_STALL_OFFSET 0x920 +#define GC_USB_DIEPCTL1_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL1_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL1_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL1_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_TXFNUM_OFFSET 0x920 +#define GC_USB_DIEPCTL1_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL1_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL1_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL1_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_CNAK_OFFSET 0x920 +#define GC_USB_DIEPCTL1_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL1_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL1_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL1_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_SNAK_OFFSET 0x920 +#define GC_USB_DIEPCTL1_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL1_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL1_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL1_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_SETD0PID_OFFSET 0x920 +#define GC_USB_DIEPCTL1_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL1_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL1_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL1_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_SETD1PID_OFFSET 0x920 +#define GC_USB_DIEPCTL1_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL1_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL1_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL1_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_EPDIS_OFFSET 0x920 +#define GC_USB_DIEPCTL1_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL1_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL1_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL1_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL1_EPENA_OFFSET 0x920 +#define GC_USB_DIEPINT1_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT1_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT1_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT1_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT1_XFERCOMPL_OFFSET 0x928 +#define GC_USB_DIEPINT1_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT1_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT1_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT1_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT1_EPDISBLD_OFFSET 0x928 +#define GC_USB_DIEPINT1_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT1_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT1_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT1_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT1_AHBERR_OFFSET 0x928 +#define GC_USB_DIEPINT1_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT1_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT1_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT1_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT1_TIMEOUT_OFFSET 0x928 +#define GC_USB_DIEPINT1_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT1_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT1_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT1_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT1_INTKNTXFEMP_OFFSET 0x928 +#define GC_USB_DIEPINT1_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT1_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT1_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT1_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT1_INTKNEPMIS_OFFSET 0x928 +#define GC_USB_DIEPINT1_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT1_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT1_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT1_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT1_INEPNAKEFF_OFFSET 0x928 +#define GC_USB_DIEPINT1_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT1_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT1_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT1_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT1_TXFEMP_OFFSET 0x928 +#define GC_USB_DIEPINT1_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT1_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT1_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT1_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT1_TXFIFOUNDRN_OFFSET 0x928 +#define GC_USB_DIEPINT1_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT1_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT1_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT1_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT1_BNAINTR_OFFSET 0x928 +#define GC_USB_DIEPINT1_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT1_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT1_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT1_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT1_PKTDRPSTS_OFFSET 0x928 +#define GC_USB_DIEPINT1_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT1_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT1_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT1_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT1_BBLEERR_OFFSET 0x928 +#define GC_USB_DIEPINT1_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT1_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT1_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT1_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT1_NAKINTRPT_OFFSET 0x928 +#define GC_USB_DIEPINT1_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT1_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT1_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT1_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT1_NYETINTRPT_OFFSET 0x928 +#define GC_USB_DIEPTSIZ1_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ1_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ1_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ1_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ1_XFERSIZE_OFFSET 0x930 +#define GC_USB_DIEPTSIZ1_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ1_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ1_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ1_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ1_PKTCNT_OFFSET 0x930 +#define GC_USB_DIEPTSIZ1_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ1_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ1_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ1_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ1_MC_OFFSET 0x930 +#define GC_USB_DIEPDMA1_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA1_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA1_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA1_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA1_DMAADDR_OFFSET 0x934 +#define GC_USB_DTXFSTS1_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS1_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS1_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS1_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS1_INEPTXFSPCAVAIL_OFFSET 0x938 +#define GC_USB_DIEPDMAB1_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB1_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB1_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB1_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB1_DMABUFFERADDR_OFFSET 0x93c +#define GC_USB_DIEPCTL2_MPS_LSB 0x0 +#define GC_USB_DIEPCTL2_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL2_MPS_SIZE 0xb +#define GC_USB_DIEPCTL2_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_MPS_OFFSET 0x940 +#define GC_USB_DIEPCTL2_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL2_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL2_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL2_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_USBACTEP_OFFSET 0x940 +#define GC_USB_DIEPCTL2_DPID_LSB 0x10 +#define GC_USB_DIEPCTL2_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL2_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL2_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_DPID_OFFSET 0x940 +#define GC_USB_DIEPCTL2_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL2_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL2_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL2_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_NAKSTS_OFFSET 0x940 +#define GC_USB_DIEPCTL2_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL2_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL2_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL2_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_EPTYPE_OFFSET 0x940 +#define GC_USB_DIEPCTL2_STALL_LSB 0x15 +#define GC_USB_DIEPCTL2_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL2_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL2_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_STALL_OFFSET 0x940 +#define GC_USB_DIEPCTL2_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL2_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL2_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL2_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_TXFNUM_OFFSET 0x940 +#define GC_USB_DIEPCTL2_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL2_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL2_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL2_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_CNAK_OFFSET 0x940 +#define GC_USB_DIEPCTL2_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL2_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL2_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL2_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_SNAK_OFFSET 0x940 +#define GC_USB_DIEPCTL2_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL2_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL2_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL2_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_SETD0PID_OFFSET 0x940 +#define GC_USB_DIEPCTL2_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL2_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL2_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL2_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_SETD1PID_OFFSET 0x940 +#define GC_USB_DIEPCTL2_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL2_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL2_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL2_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_EPDIS_OFFSET 0x940 +#define GC_USB_DIEPCTL2_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL2_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL2_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL2_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL2_EPENA_OFFSET 0x940 +#define GC_USB_DIEPINT2_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT2_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT2_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT2_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT2_XFERCOMPL_OFFSET 0x948 +#define GC_USB_DIEPINT2_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT2_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT2_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT2_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT2_EPDISBLD_OFFSET 0x948 +#define GC_USB_DIEPINT2_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT2_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT2_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT2_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT2_AHBERR_OFFSET 0x948 +#define GC_USB_DIEPINT2_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT2_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT2_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT2_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT2_TIMEOUT_OFFSET 0x948 +#define GC_USB_DIEPINT2_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT2_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT2_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT2_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT2_INTKNTXFEMP_OFFSET 0x948 +#define GC_USB_DIEPINT2_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT2_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT2_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT2_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT2_INTKNEPMIS_OFFSET 0x948 +#define GC_USB_DIEPINT2_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT2_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT2_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT2_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT2_INEPNAKEFF_OFFSET 0x948 +#define GC_USB_DIEPINT2_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT2_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT2_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT2_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT2_TXFEMP_OFFSET 0x948 +#define GC_USB_DIEPINT2_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT2_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT2_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT2_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT2_TXFIFOUNDRN_OFFSET 0x948 +#define GC_USB_DIEPINT2_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT2_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT2_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT2_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT2_BNAINTR_OFFSET 0x948 +#define GC_USB_DIEPINT2_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT2_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT2_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT2_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT2_PKTDRPSTS_OFFSET 0x948 +#define GC_USB_DIEPINT2_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT2_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT2_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT2_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT2_BBLEERR_OFFSET 0x948 +#define GC_USB_DIEPINT2_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT2_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT2_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT2_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT2_NAKINTRPT_OFFSET 0x948 +#define GC_USB_DIEPINT2_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT2_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT2_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT2_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT2_NYETINTRPT_OFFSET 0x948 +#define GC_USB_DIEPTSIZ2_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ2_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ2_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ2_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ2_XFERSIZE_OFFSET 0x950 +#define GC_USB_DIEPTSIZ2_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ2_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ2_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ2_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ2_PKTCNT_OFFSET 0x950 +#define GC_USB_DIEPTSIZ2_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ2_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ2_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ2_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ2_MC_OFFSET 0x950 +#define GC_USB_DIEPDMA2_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA2_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA2_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA2_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA2_DMAADDR_OFFSET 0x954 +#define GC_USB_DTXFSTS2_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS2_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS2_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS2_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS2_INEPTXFSPCAVAIL_OFFSET 0x958 +#define GC_USB_DIEPDMAB2_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB2_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB2_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB2_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB2_DMABUFFERADDR_OFFSET 0x95c +#define GC_USB_DIEPCTL3_MPS_LSB 0x0 +#define GC_USB_DIEPCTL3_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL3_MPS_SIZE 0xb +#define GC_USB_DIEPCTL3_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_MPS_OFFSET 0x960 +#define GC_USB_DIEPCTL3_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL3_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL3_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL3_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_USBACTEP_OFFSET 0x960 +#define GC_USB_DIEPCTL3_DPID_LSB 0x10 +#define GC_USB_DIEPCTL3_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL3_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL3_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_DPID_OFFSET 0x960 +#define GC_USB_DIEPCTL3_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL3_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL3_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL3_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_NAKSTS_OFFSET 0x960 +#define GC_USB_DIEPCTL3_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL3_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL3_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL3_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_EPTYPE_OFFSET 0x960 +#define GC_USB_DIEPCTL3_STALL_LSB 0x15 +#define GC_USB_DIEPCTL3_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL3_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL3_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_STALL_OFFSET 0x960 +#define GC_USB_DIEPCTL3_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL3_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL3_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL3_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_TXFNUM_OFFSET 0x960 +#define GC_USB_DIEPCTL3_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL3_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL3_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL3_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_CNAK_OFFSET 0x960 +#define GC_USB_DIEPCTL3_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL3_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL3_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL3_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_SNAK_OFFSET 0x960 +#define GC_USB_DIEPCTL3_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL3_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL3_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL3_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_SETD0PID_OFFSET 0x960 +#define GC_USB_DIEPCTL3_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL3_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL3_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL3_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_SETD1PID_OFFSET 0x960 +#define GC_USB_DIEPCTL3_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL3_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL3_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL3_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_EPDIS_OFFSET 0x960 +#define GC_USB_DIEPCTL3_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL3_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL3_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL3_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL3_EPENA_OFFSET 0x960 +#define GC_USB_DIEPINT3_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT3_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT3_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT3_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT3_XFERCOMPL_OFFSET 0x968 +#define GC_USB_DIEPINT3_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT3_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT3_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT3_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT3_EPDISBLD_OFFSET 0x968 +#define GC_USB_DIEPINT3_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT3_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT3_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT3_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT3_AHBERR_OFFSET 0x968 +#define GC_USB_DIEPINT3_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT3_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT3_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT3_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT3_TIMEOUT_OFFSET 0x968 +#define GC_USB_DIEPINT3_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT3_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT3_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT3_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT3_INTKNTXFEMP_OFFSET 0x968 +#define GC_USB_DIEPINT3_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT3_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT3_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT3_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT3_INTKNEPMIS_OFFSET 0x968 +#define GC_USB_DIEPINT3_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT3_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT3_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT3_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT3_INEPNAKEFF_OFFSET 0x968 +#define GC_USB_DIEPINT3_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT3_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT3_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT3_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT3_TXFEMP_OFFSET 0x968 +#define GC_USB_DIEPINT3_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT3_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT3_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT3_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT3_TXFIFOUNDRN_OFFSET 0x968 +#define GC_USB_DIEPINT3_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT3_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT3_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT3_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT3_BNAINTR_OFFSET 0x968 +#define GC_USB_DIEPINT3_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT3_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT3_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT3_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT3_PKTDRPSTS_OFFSET 0x968 +#define GC_USB_DIEPINT3_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT3_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT3_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT3_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT3_BBLEERR_OFFSET 0x968 +#define GC_USB_DIEPINT3_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT3_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT3_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT3_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT3_NAKINTRPT_OFFSET 0x968 +#define GC_USB_DIEPINT3_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT3_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT3_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT3_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT3_NYETINTRPT_OFFSET 0x968 +#define GC_USB_DIEPTSIZ3_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ3_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ3_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ3_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ3_XFERSIZE_OFFSET 0x970 +#define GC_USB_DIEPTSIZ3_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ3_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ3_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ3_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ3_PKTCNT_OFFSET 0x970 +#define GC_USB_DIEPTSIZ3_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ3_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ3_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ3_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ3_MC_OFFSET 0x970 +#define GC_USB_DIEPDMA3_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA3_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA3_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA3_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA3_DMAADDR_OFFSET 0x974 +#define GC_USB_DTXFSTS3_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS3_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS3_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS3_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS3_INEPTXFSPCAVAIL_OFFSET 0x978 +#define GC_USB_DIEPDMAB3_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB3_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB3_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB3_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB3_DMABUFFERADDR_OFFSET 0x97c +#define GC_USB_DIEPCTL4_MPS_LSB 0x0 +#define GC_USB_DIEPCTL4_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL4_MPS_SIZE 0xb +#define GC_USB_DIEPCTL4_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_MPS_OFFSET 0x980 +#define GC_USB_DIEPCTL4_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL4_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL4_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL4_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_USBACTEP_OFFSET 0x980 +#define GC_USB_DIEPCTL4_DPID_LSB 0x10 +#define GC_USB_DIEPCTL4_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL4_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL4_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_DPID_OFFSET 0x980 +#define GC_USB_DIEPCTL4_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL4_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL4_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL4_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_NAKSTS_OFFSET 0x980 +#define GC_USB_DIEPCTL4_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL4_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL4_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL4_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_EPTYPE_OFFSET 0x980 +#define GC_USB_DIEPCTL4_STALL_LSB 0x15 +#define GC_USB_DIEPCTL4_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL4_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL4_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_STALL_OFFSET 0x980 +#define GC_USB_DIEPCTL4_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL4_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL4_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL4_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_TXFNUM_OFFSET 0x980 +#define GC_USB_DIEPCTL4_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL4_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL4_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL4_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_CNAK_OFFSET 0x980 +#define GC_USB_DIEPCTL4_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL4_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL4_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL4_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_SNAK_OFFSET 0x980 +#define GC_USB_DIEPCTL4_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL4_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL4_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL4_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_SETD0PID_OFFSET 0x980 +#define GC_USB_DIEPCTL4_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL4_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL4_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL4_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_SETD1PID_OFFSET 0x980 +#define GC_USB_DIEPCTL4_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL4_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL4_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL4_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_EPDIS_OFFSET 0x980 +#define GC_USB_DIEPCTL4_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL4_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL4_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL4_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL4_EPENA_OFFSET 0x980 +#define GC_USB_DIEPINT4_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT4_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT4_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT4_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT4_XFERCOMPL_OFFSET 0x988 +#define GC_USB_DIEPINT4_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT4_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT4_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT4_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT4_EPDISBLD_OFFSET 0x988 +#define GC_USB_DIEPINT4_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT4_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT4_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT4_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT4_AHBERR_OFFSET 0x988 +#define GC_USB_DIEPINT4_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT4_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT4_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT4_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT4_TIMEOUT_OFFSET 0x988 +#define GC_USB_DIEPINT4_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT4_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT4_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT4_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT4_INTKNTXFEMP_OFFSET 0x988 +#define GC_USB_DIEPINT4_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT4_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT4_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT4_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT4_INTKNEPMIS_OFFSET 0x988 +#define GC_USB_DIEPINT4_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT4_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT4_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT4_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT4_INEPNAKEFF_OFFSET 0x988 +#define GC_USB_DIEPINT4_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT4_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT4_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT4_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT4_TXFEMP_OFFSET 0x988 +#define GC_USB_DIEPINT4_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT4_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT4_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT4_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT4_TXFIFOUNDRN_OFFSET 0x988 +#define GC_USB_DIEPINT4_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT4_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT4_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT4_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT4_BNAINTR_OFFSET 0x988 +#define GC_USB_DIEPINT4_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT4_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT4_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT4_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT4_PKTDRPSTS_OFFSET 0x988 +#define GC_USB_DIEPINT4_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT4_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT4_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT4_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT4_BBLEERR_OFFSET 0x988 +#define GC_USB_DIEPINT4_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT4_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT4_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT4_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT4_NAKINTRPT_OFFSET 0x988 +#define GC_USB_DIEPINT4_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT4_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT4_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT4_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT4_NYETINTRPT_OFFSET 0x988 +#define GC_USB_DIEPTSIZ4_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ4_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ4_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ4_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ4_XFERSIZE_OFFSET 0x990 +#define GC_USB_DIEPTSIZ4_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ4_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ4_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ4_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ4_PKTCNT_OFFSET 0x990 +#define GC_USB_DIEPTSIZ4_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ4_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ4_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ4_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ4_MC_OFFSET 0x990 +#define GC_USB_DIEPDMA4_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA4_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA4_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA4_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA4_DMAADDR_OFFSET 0x994 +#define GC_USB_DTXFSTS4_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS4_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS4_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS4_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS4_INEPTXFSPCAVAIL_OFFSET 0x998 +#define GC_USB_DIEPDMAB4_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB4_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB4_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB4_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB4_DMABUFFERADDR_OFFSET 0x99c +#define GC_USB_DIEPCTL5_MPS_LSB 0x0 +#define GC_USB_DIEPCTL5_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL5_MPS_SIZE 0xb +#define GC_USB_DIEPCTL5_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_MPS_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL5_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL5_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL5_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_USBACTEP_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_DPID_LSB 0x10 +#define GC_USB_DIEPCTL5_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL5_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL5_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_DPID_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL5_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL5_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL5_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_NAKSTS_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL5_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL5_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL5_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_EPTYPE_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_STALL_LSB 0x15 +#define GC_USB_DIEPCTL5_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL5_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL5_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_STALL_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL5_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL5_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL5_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_TXFNUM_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL5_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL5_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL5_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_CNAK_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL5_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL5_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL5_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_SNAK_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL5_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL5_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL5_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_SETD0PID_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL5_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL5_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL5_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_SETD1PID_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL5_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL5_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL5_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_EPDIS_OFFSET 0x9a0 +#define GC_USB_DIEPCTL5_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL5_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL5_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL5_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL5_EPENA_OFFSET 0x9a0 +#define GC_USB_DIEPINT5_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT5_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT5_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT5_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT5_XFERCOMPL_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT5_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT5_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT5_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT5_EPDISBLD_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT5_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT5_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT5_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT5_AHBERR_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT5_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT5_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT5_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT5_TIMEOUT_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT5_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT5_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT5_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT5_INTKNTXFEMP_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT5_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT5_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT5_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT5_INTKNEPMIS_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT5_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT5_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT5_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT5_INEPNAKEFF_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT5_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT5_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT5_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT5_TXFEMP_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT5_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT5_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT5_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT5_TXFIFOUNDRN_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT5_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT5_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT5_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT5_BNAINTR_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT5_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT5_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT5_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT5_PKTDRPSTS_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT5_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT5_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT5_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT5_BBLEERR_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT5_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT5_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT5_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT5_NAKINTRPT_OFFSET 0x9a8 +#define GC_USB_DIEPINT5_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT5_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT5_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT5_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT5_NYETINTRPT_OFFSET 0x9a8 +#define GC_USB_DIEPTSIZ5_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ5_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ5_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ5_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ5_XFERSIZE_OFFSET 0x9b0 +#define GC_USB_DIEPTSIZ5_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ5_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ5_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ5_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ5_PKTCNT_OFFSET 0x9b0 +#define GC_USB_DIEPTSIZ5_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ5_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ5_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ5_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ5_MC_OFFSET 0x9b0 +#define GC_USB_DIEPDMA5_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA5_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA5_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA5_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA5_DMAADDR_OFFSET 0x9b4 +#define GC_USB_DTXFSTS5_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS5_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS5_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS5_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS5_INEPTXFSPCAVAIL_OFFSET 0x9b8 +#define GC_USB_DIEPDMAB5_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB5_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB5_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB5_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB5_DMABUFFERADDR_OFFSET 0x9bc +#define GC_USB_DIEPCTL6_MPS_LSB 0x0 +#define GC_USB_DIEPCTL6_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL6_MPS_SIZE 0xb +#define GC_USB_DIEPCTL6_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_MPS_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL6_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL6_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL6_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_USBACTEP_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_DPID_LSB 0x10 +#define GC_USB_DIEPCTL6_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL6_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL6_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_DPID_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL6_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL6_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL6_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_NAKSTS_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL6_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL6_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL6_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_EPTYPE_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_STALL_LSB 0x15 +#define GC_USB_DIEPCTL6_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL6_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL6_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_STALL_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL6_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL6_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL6_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_TXFNUM_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL6_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL6_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL6_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_CNAK_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL6_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL6_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL6_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_SNAK_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL6_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL6_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL6_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_SETD0PID_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL6_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL6_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL6_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_SETD1PID_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL6_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL6_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL6_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_EPDIS_OFFSET 0x9c0 +#define GC_USB_DIEPCTL6_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL6_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL6_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL6_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL6_EPENA_OFFSET 0x9c0 +#define GC_USB_DIEPINT6_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT6_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT6_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT6_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT6_XFERCOMPL_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT6_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT6_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT6_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT6_EPDISBLD_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT6_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT6_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT6_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT6_AHBERR_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT6_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT6_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT6_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT6_TIMEOUT_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT6_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT6_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT6_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT6_INTKNTXFEMP_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT6_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT6_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT6_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT6_INTKNEPMIS_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT6_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT6_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT6_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT6_INEPNAKEFF_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT6_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT6_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT6_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT6_TXFEMP_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT6_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT6_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT6_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT6_TXFIFOUNDRN_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT6_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT6_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT6_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT6_BNAINTR_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT6_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT6_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT6_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT6_PKTDRPSTS_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT6_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT6_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT6_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT6_BBLEERR_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT6_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT6_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT6_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT6_NAKINTRPT_OFFSET 0x9c8 +#define GC_USB_DIEPINT6_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT6_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT6_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT6_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT6_NYETINTRPT_OFFSET 0x9c8 +#define GC_USB_DIEPTSIZ6_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ6_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ6_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ6_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ6_XFERSIZE_OFFSET 0x9d0 +#define GC_USB_DIEPTSIZ6_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ6_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ6_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ6_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ6_PKTCNT_OFFSET 0x9d0 +#define GC_USB_DIEPTSIZ6_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ6_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ6_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ6_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ6_MC_OFFSET 0x9d0 +#define GC_USB_DIEPDMA6_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA6_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA6_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA6_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA6_DMAADDR_OFFSET 0x9d4 +#define GC_USB_DTXFSTS6_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS6_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS6_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS6_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS6_INEPTXFSPCAVAIL_OFFSET 0x9d8 +#define GC_USB_DIEPDMAB6_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB6_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB6_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB6_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB6_DMABUFFERADDR_OFFSET 0x9dc +#define GC_USB_DIEPCTL7_MPS_LSB 0x0 +#define GC_USB_DIEPCTL7_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL7_MPS_SIZE 0xb +#define GC_USB_DIEPCTL7_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_MPS_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL7_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL7_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL7_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_USBACTEP_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_DPID_LSB 0x10 +#define GC_USB_DIEPCTL7_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL7_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL7_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_DPID_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL7_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL7_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL7_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_NAKSTS_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL7_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL7_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL7_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_EPTYPE_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_STALL_LSB 0x15 +#define GC_USB_DIEPCTL7_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL7_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL7_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_STALL_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL7_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL7_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL7_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_TXFNUM_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL7_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL7_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL7_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_CNAK_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL7_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL7_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL7_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_SNAK_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL7_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL7_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL7_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_SETD0PID_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL7_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL7_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL7_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_SETD1PID_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL7_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL7_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL7_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_EPDIS_OFFSET 0x9e0 +#define GC_USB_DIEPCTL7_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL7_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL7_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL7_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL7_EPENA_OFFSET 0x9e0 +#define GC_USB_DIEPINT7_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT7_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT7_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT7_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT7_XFERCOMPL_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT7_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT7_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT7_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT7_EPDISBLD_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT7_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT7_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT7_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT7_AHBERR_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT7_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT7_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT7_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT7_TIMEOUT_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT7_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT7_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT7_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT7_INTKNTXFEMP_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT7_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT7_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT7_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT7_INTKNEPMIS_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT7_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT7_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT7_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT7_INEPNAKEFF_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT7_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT7_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT7_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT7_TXFEMP_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT7_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT7_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT7_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT7_TXFIFOUNDRN_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT7_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT7_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT7_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT7_BNAINTR_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT7_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT7_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT7_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT7_PKTDRPSTS_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT7_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT7_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT7_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT7_BBLEERR_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT7_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT7_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT7_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT7_NAKINTRPT_OFFSET 0x9e8 +#define GC_USB_DIEPINT7_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT7_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT7_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT7_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT7_NYETINTRPT_OFFSET 0x9e8 +#define GC_USB_DIEPTSIZ7_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ7_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ7_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ7_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ7_XFERSIZE_OFFSET 0x9f0 +#define GC_USB_DIEPTSIZ7_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ7_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ7_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ7_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ7_PKTCNT_OFFSET 0x9f0 +#define GC_USB_DIEPTSIZ7_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ7_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ7_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ7_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ7_MC_OFFSET 0x9f0 +#define GC_USB_DIEPDMA7_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA7_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA7_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA7_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA7_DMAADDR_OFFSET 0x9f4 +#define GC_USB_DTXFSTS7_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS7_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS7_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS7_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS7_INEPTXFSPCAVAIL_OFFSET 0x9f8 +#define GC_USB_DIEPDMAB7_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB7_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB7_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB7_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB7_DMABUFFERADDR_OFFSET 0x9fc +#define GC_USB_DIEPCTL8_MPS_LSB 0x0 +#define GC_USB_DIEPCTL8_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL8_MPS_SIZE 0xb +#define GC_USB_DIEPCTL8_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_MPS_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL8_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL8_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL8_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_USBACTEP_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_DPID_LSB 0x10 +#define GC_USB_DIEPCTL8_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL8_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL8_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_DPID_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL8_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL8_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL8_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_NAKSTS_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL8_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL8_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL8_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_EPTYPE_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_STALL_LSB 0x15 +#define GC_USB_DIEPCTL8_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL8_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL8_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_STALL_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL8_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL8_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL8_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_TXFNUM_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL8_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL8_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL8_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_CNAK_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL8_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL8_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL8_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_SNAK_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL8_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL8_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL8_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_SETD0PID_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL8_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL8_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL8_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_SETD1PID_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL8_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL8_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL8_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_EPDIS_OFFSET 0xa00 +#define GC_USB_DIEPCTL8_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL8_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL8_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL8_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL8_EPENA_OFFSET 0xa00 +#define GC_USB_DIEPINT8_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT8_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT8_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT8_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT8_XFERCOMPL_OFFSET 0xa08 +#define GC_USB_DIEPINT8_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT8_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT8_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT8_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT8_EPDISBLD_OFFSET 0xa08 +#define GC_USB_DIEPINT8_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT8_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT8_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT8_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT8_AHBERR_OFFSET 0xa08 +#define GC_USB_DIEPINT8_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT8_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT8_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT8_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT8_TIMEOUT_OFFSET 0xa08 +#define GC_USB_DIEPINT8_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT8_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT8_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT8_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT8_INTKNTXFEMP_OFFSET 0xa08 +#define GC_USB_DIEPINT8_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT8_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT8_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT8_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT8_INTKNEPMIS_OFFSET 0xa08 +#define GC_USB_DIEPINT8_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT8_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT8_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT8_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT8_INEPNAKEFF_OFFSET 0xa08 +#define GC_USB_DIEPINT8_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT8_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT8_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT8_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT8_TXFEMP_OFFSET 0xa08 +#define GC_USB_DIEPINT8_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT8_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT8_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT8_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT8_TXFIFOUNDRN_OFFSET 0xa08 +#define GC_USB_DIEPINT8_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT8_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT8_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT8_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT8_BNAINTR_OFFSET 0xa08 +#define GC_USB_DIEPINT8_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT8_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT8_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT8_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT8_PKTDRPSTS_OFFSET 0xa08 +#define GC_USB_DIEPINT8_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT8_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT8_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT8_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT8_BBLEERR_OFFSET 0xa08 +#define GC_USB_DIEPINT8_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT8_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT8_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT8_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT8_NAKINTRPT_OFFSET 0xa08 +#define GC_USB_DIEPINT8_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT8_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT8_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT8_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT8_NYETINTRPT_OFFSET 0xa08 +#define GC_USB_DIEPTSIZ8_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ8_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ8_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ8_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ8_XFERSIZE_OFFSET 0xa10 +#define GC_USB_DIEPTSIZ8_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ8_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ8_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ8_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ8_PKTCNT_OFFSET 0xa10 +#define GC_USB_DIEPTSIZ8_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ8_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ8_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ8_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ8_MC_OFFSET 0xa10 +#define GC_USB_DIEPDMA8_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA8_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA8_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA8_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA8_DMAADDR_OFFSET 0xa14 +#define GC_USB_DTXFSTS8_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS8_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS8_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS8_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS8_INEPTXFSPCAVAIL_OFFSET 0xa18 +#define GC_USB_DIEPDMAB8_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB8_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB8_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB8_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB8_DMABUFFERADDR_OFFSET 0xa1c +#define GC_USB_DIEPCTL9_MPS_LSB 0x0 +#define GC_USB_DIEPCTL9_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL9_MPS_SIZE 0xb +#define GC_USB_DIEPCTL9_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_MPS_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL9_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL9_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL9_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_USBACTEP_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_DPID_LSB 0x10 +#define GC_USB_DIEPCTL9_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL9_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL9_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_DPID_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL9_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL9_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL9_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_NAKSTS_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL9_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL9_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL9_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_EPTYPE_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_STALL_LSB 0x15 +#define GC_USB_DIEPCTL9_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL9_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL9_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_STALL_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL9_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL9_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL9_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_TXFNUM_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL9_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL9_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL9_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_CNAK_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL9_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL9_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL9_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_SNAK_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL9_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL9_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL9_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_SETD0PID_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL9_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL9_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL9_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_SETD1PID_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL9_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL9_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL9_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_EPDIS_OFFSET 0xa20 +#define GC_USB_DIEPCTL9_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL9_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL9_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL9_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL9_EPENA_OFFSET 0xa20 +#define GC_USB_DIEPINT9_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT9_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT9_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT9_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT9_XFERCOMPL_OFFSET 0xa28 +#define GC_USB_DIEPINT9_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT9_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT9_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT9_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT9_EPDISBLD_OFFSET 0xa28 +#define GC_USB_DIEPINT9_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT9_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT9_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT9_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT9_AHBERR_OFFSET 0xa28 +#define GC_USB_DIEPINT9_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT9_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT9_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT9_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT9_TIMEOUT_OFFSET 0xa28 +#define GC_USB_DIEPINT9_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT9_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT9_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT9_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT9_INTKNTXFEMP_OFFSET 0xa28 +#define GC_USB_DIEPINT9_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT9_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT9_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT9_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT9_INTKNEPMIS_OFFSET 0xa28 +#define GC_USB_DIEPINT9_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT9_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT9_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT9_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT9_INEPNAKEFF_OFFSET 0xa28 +#define GC_USB_DIEPINT9_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT9_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT9_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT9_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT9_TXFEMP_OFFSET 0xa28 +#define GC_USB_DIEPINT9_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT9_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT9_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT9_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT9_TXFIFOUNDRN_OFFSET 0xa28 +#define GC_USB_DIEPINT9_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT9_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT9_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT9_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT9_BNAINTR_OFFSET 0xa28 +#define GC_USB_DIEPINT9_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT9_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT9_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT9_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT9_PKTDRPSTS_OFFSET 0xa28 +#define GC_USB_DIEPINT9_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT9_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT9_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT9_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT9_BBLEERR_OFFSET 0xa28 +#define GC_USB_DIEPINT9_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT9_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT9_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT9_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT9_NAKINTRPT_OFFSET 0xa28 +#define GC_USB_DIEPINT9_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT9_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT9_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT9_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT9_NYETINTRPT_OFFSET 0xa28 +#define GC_USB_DIEPTSIZ9_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ9_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ9_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ9_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ9_XFERSIZE_OFFSET 0xa30 +#define GC_USB_DIEPTSIZ9_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ9_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ9_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ9_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ9_PKTCNT_OFFSET 0xa30 +#define GC_USB_DIEPTSIZ9_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ9_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ9_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ9_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ9_MC_OFFSET 0xa30 +#define GC_USB_DIEPDMA9_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA9_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA9_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA9_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA9_DMAADDR_OFFSET 0xa34 +#define GC_USB_DTXFSTS9_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS9_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS9_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS9_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS9_INEPTXFSPCAVAIL_OFFSET 0xa38 +#define GC_USB_DIEPDMAB9_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB9_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB9_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB9_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB9_DMABUFFERADDR_OFFSET 0xa3c +#define GC_USB_DIEPCTL10_MPS_LSB 0x0 +#define GC_USB_DIEPCTL10_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL10_MPS_SIZE 0xb +#define GC_USB_DIEPCTL10_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_MPS_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL10_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL10_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL10_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_USBACTEP_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_DPID_LSB 0x10 +#define GC_USB_DIEPCTL10_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL10_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL10_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_DPID_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL10_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL10_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL10_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_NAKSTS_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL10_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL10_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL10_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_EPTYPE_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_STALL_LSB 0x15 +#define GC_USB_DIEPCTL10_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL10_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL10_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_STALL_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL10_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL10_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL10_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_TXFNUM_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL10_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL10_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL10_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_CNAK_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL10_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL10_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL10_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_SNAK_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL10_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL10_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL10_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_SETD0PID_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL10_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL10_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL10_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_SETD1PID_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL10_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL10_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL10_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_EPDIS_OFFSET 0xa40 +#define GC_USB_DIEPCTL10_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL10_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL10_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL10_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL10_EPENA_OFFSET 0xa40 +#define GC_USB_DIEPINT10_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT10_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT10_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT10_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT10_XFERCOMPL_OFFSET 0xa48 +#define GC_USB_DIEPINT10_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT10_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT10_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT10_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT10_EPDISBLD_OFFSET 0xa48 +#define GC_USB_DIEPINT10_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT10_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT10_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT10_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT10_AHBERR_OFFSET 0xa48 +#define GC_USB_DIEPINT10_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT10_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT10_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT10_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT10_TIMEOUT_OFFSET 0xa48 +#define GC_USB_DIEPINT10_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT10_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT10_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT10_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT10_INTKNTXFEMP_OFFSET 0xa48 +#define GC_USB_DIEPINT10_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT10_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT10_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT10_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT10_INTKNEPMIS_OFFSET 0xa48 +#define GC_USB_DIEPINT10_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT10_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT10_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT10_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT10_INEPNAKEFF_OFFSET 0xa48 +#define GC_USB_DIEPINT10_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT10_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT10_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT10_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT10_TXFEMP_OFFSET 0xa48 +#define GC_USB_DIEPINT10_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT10_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT10_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT10_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT10_TXFIFOUNDRN_OFFSET 0xa48 +#define GC_USB_DIEPINT10_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT10_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT10_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT10_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT10_BNAINTR_OFFSET 0xa48 +#define GC_USB_DIEPINT10_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT10_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT10_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT10_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT10_PKTDRPSTS_OFFSET 0xa48 +#define GC_USB_DIEPINT10_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT10_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT10_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT10_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT10_BBLEERR_OFFSET 0xa48 +#define GC_USB_DIEPINT10_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT10_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT10_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT10_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT10_NAKINTRPT_OFFSET 0xa48 +#define GC_USB_DIEPINT10_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT10_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT10_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT10_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT10_NYETINTRPT_OFFSET 0xa48 +#define GC_USB_DIEPTSIZ10_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ10_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ10_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ10_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ10_XFERSIZE_OFFSET 0xa50 +#define GC_USB_DIEPTSIZ10_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ10_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ10_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ10_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ10_PKTCNT_OFFSET 0xa50 +#define GC_USB_DIEPTSIZ10_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ10_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ10_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ10_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ10_MC_OFFSET 0xa50 +#define GC_USB_DIEPDMA10_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA10_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA10_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA10_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA10_DMAADDR_OFFSET 0xa54 +#define GC_USB_DTXFSTS10_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS10_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS10_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS10_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS10_INEPTXFSPCAVAIL_OFFSET 0xa58 +#define GC_USB_DIEPDMAB10_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB10_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB10_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB10_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB10_DMABUFFERADDR_OFFSET 0xa5c +#define GC_USB_DIEPCTL11_MPS_LSB 0x0 +#define GC_USB_DIEPCTL11_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL11_MPS_SIZE 0xb +#define GC_USB_DIEPCTL11_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_MPS_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL11_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL11_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL11_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_USBACTEP_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_DPID_LSB 0x10 +#define GC_USB_DIEPCTL11_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL11_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL11_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_DPID_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL11_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL11_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL11_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_NAKSTS_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL11_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL11_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL11_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_EPTYPE_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_STALL_LSB 0x15 +#define GC_USB_DIEPCTL11_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL11_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL11_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_STALL_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL11_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL11_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL11_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_TXFNUM_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL11_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL11_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL11_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_CNAK_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL11_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL11_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL11_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_SNAK_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL11_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL11_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL11_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_SETD0PID_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL11_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL11_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL11_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_SETD1PID_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL11_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL11_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL11_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_EPDIS_OFFSET 0xa60 +#define GC_USB_DIEPCTL11_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL11_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL11_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL11_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL11_EPENA_OFFSET 0xa60 +#define GC_USB_DIEPINT11_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT11_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT11_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT11_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT11_XFERCOMPL_OFFSET 0xa68 +#define GC_USB_DIEPINT11_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT11_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT11_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT11_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT11_EPDISBLD_OFFSET 0xa68 +#define GC_USB_DIEPINT11_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT11_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT11_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT11_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT11_AHBERR_OFFSET 0xa68 +#define GC_USB_DIEPINT11_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT11_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT11_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT11_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT11_TIMEOUT_OFFSET 0xa68 +#define GC_USB_DIEPINT11_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT11_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT11_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT11_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT11_INTKNTXFEMP_OFFSET 0xa68 +#define GC_USB_DIEPINT11_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT11_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT11_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT11_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT11_INTKNEPMIS_OFFSET 0xa68 +#define GC_USB_DIEPINT11_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT11_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT11_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT11_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT11_INEPNAKEFF_OFFSET 0xa68 +#define GC_USB_DIEPINT11_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT11_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT11_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT11_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT11_TXFEMP_OFFSET 0xa68 +#define GC_USB_DIEPINT11_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT11_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT11_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT11_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT11_TXFIFOUNDRN_OFFSET 0xa68 +#define GC_USB_DIEPINT11_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT11_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT11_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT11_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT11_BNAINTR_OFFSET 0xa68 +#define GC_USB_DIEPINT11_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT11_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT11_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT11_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT11_PKTDRPSTS_OFFSET 0xa68 +#define GC_USB_DIEPINT11_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT11_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT11_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT11_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT11_BBLEERR_OFFSET 0xa68 +#define GC_USB_DIEPINT11_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT11_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT11_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT11_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT11_NAKINTRPT_OFFSET 0xa68 +#define GC_USB_DIEPINT11_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT11_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT11_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT11_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT11_NYETINTRPT_OFFSET 0xa68 +#define GC_USB_DIEPTSIZ11_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ11_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ11_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ11_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ11_XFERSIZE_OFFSET 0xa70 +#define GC_USB_DIEPTSIZ11_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ11_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ11_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ11_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ11_PKTCNT_OFFSET 0xa70 +#define GC_USB_DIEPTSIZ11_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ11_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ11_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ11_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ11_MC_OFFSET 0xa70 +#define GC_USB_DIEPDMA11_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA11_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA11_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA11_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA11_DMAADDR_OFFSET 0xa74 +#define GC_USB_DTXFSTS11_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS11_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS11_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS11_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS11_INEPTXFSPCAVAIL_OFFSET 0xa78 +#define GC_USB_DIEPDMAB11_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB11_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB11_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB11_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB11_DMABUFFERADDR_OFFSET 0xa7c +#define GC_USB_DIEPCTL12_MPS_LSB 0x0 +#define GC_USB_DIEPCTL12_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL12_MPS_SIZE 0xb +#define GC_USB_DIEPCTL12_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_MPS_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL12_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL12_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL12_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_USBACTEP_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_DPID_LSB 0x10 +#define GC_USB_DIEPCTL12_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL12_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL12_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_DPID_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL12_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL12_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL12_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_NAKSTS_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL12_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL12_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL12_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_EPTYPE_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_STALL_LSB 0x15 +#define GC_USB_DIEPCTL12_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL12_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL12_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_STALL_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL12_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL12_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL12_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_TXFNUM_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL12_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL12_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL12_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_CNAK_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL12_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL12_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL12_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_SNAK_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL12_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL12_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL12_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_SETD0PID_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL12_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL12_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL12_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_SETD1PID_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL12_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL12_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL12_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_EPDIS_OFFSET 0xa80 +#define GC_USB_DIEPCTL12_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL12_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL12_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL12_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL12_EPENA_OFFSET 0xa80 +#define GC_USB_DIEPINT12_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT12_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT12_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT12_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT12_XFERCOMPL_OFFSET 0xa88 +#define GC_USB_DIEPINT12_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT12_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT12_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT12_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT12_EPDISBLD_OFFSET 0xa88 +#define GC_USB_DIEPINT12_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT12_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT12_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT12_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT12_AHBERR_OFFSET 0xa88 +#define GC_USB_DIEPINT12_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT12_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT12_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT12_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT12_TIMEOUT_OFFSET 0xa88 +#define GC_USB_DIEPINT12_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT12_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT12_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT12_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT12_INTKNTXFEMP_OFFSET 0xa88 +#define GC_USB_DIEPINT12_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT12_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT12_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT12_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT12_INTKNEPMIS_OFFSET 0xa88 +#define GC_USB_DIEPINT12_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT12_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT12_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT12_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT12_INEPNAKEFF_OFFSET 0xa88 +#define GC_USB_DIEPINT12_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT12_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT12_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT12_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT12_TXFEMP_OFFSET 0xa88 +#define GC_USB_DIEPINT12_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT12_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT12_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT12_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT12_TXFIFOUNDRN_OFFSET 0xa88 +#define GC_USB_DIEPINT12_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT12_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT12_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT12_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT12_BNAINTR_OFFSET 0xa88 +#define GC_USB_DIEPINT12_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT12_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT12_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT12_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT12_PKTDRPSTS_OFFSET 0xa88 +#define GC_USB_DIEPINT12_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT12_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT12_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT12_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT12_BBLEERR_OFFSET 0xa88 +#define GC_USB_DIEPINT12_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT12_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT12_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT12_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT12_NAKINTRPT_OFFSET 0xa88 +#define GC_USB_DIEPINT12_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT12_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT12_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT12_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT12_NYETINTRPT_OFFSET 0xa88 +#define GC_USB_DIEPTSIZ12_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ12_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ12_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ12_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ12_XFERSIZE_OFFSET 0xa90 +#define GC_USB_DIEPTSIZ12_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ12_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ12_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ12_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ12_PKTCNT_OFFSET 0xa90 +#define GC_USB_DIEPTSIZ12_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ12_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ12_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ12_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ12_MC_OFFSET 0xa90 +#define GC_USB_DIEPDMA12_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA12_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA12_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA12_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA12_DMAADDR_OFFSET 0xa94 +#define GC_USB_DTXFSTS12_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS12_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS12_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS12_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS12_INEPTXFSPCAVAIL_OFFSET 0xa98 +#define GC_USB_DIEPDMAB12_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB12_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB12_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB12_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB12_DMABUFFERADDR_OFFSET 0xa9c +#define GC_USB_DIEPCTL13_MPS_LSB 0x0 +#define GC_USB_DIEPCTL13_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL13_MPS_SIZE 0xb +#define GC_USB_DIEPCTL13_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_MPS_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL13_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL13_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL13_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_USBACTEP_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_DPID_LSB 0x10 +#define GC_USB_DIEPCTL13_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL13_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL13_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_DPID_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL13_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL13_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL13_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_NAKSTS_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL13_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL13_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL13_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_EPTYPE_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_STALL_LSB 0x15 +#define GC_USB_DIEPCTL13_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL13_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL13_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_STALL_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL13_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL13_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL13_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_TXFNUM_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL13_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL13_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL13_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_CNAK_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL13_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL13_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL13_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_SNAK_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL13_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL13_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL13_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_SETD0PID_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL13_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL13_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL13_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_SETD1PID_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL13_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL13_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL13_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_EPDIS_OFFSET 0xaa0 +#define GC_USB_DIEPCTL13_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL13_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL13_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL13_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL13_EPENA_OFFSET 0xaa0 +#define GC_USB_DIEPINT13_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT13_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT13_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT13_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT13_XFERCOMPL_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT13_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT13_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT13_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT13_EPDISBLD_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT13_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT13_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT13_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT13_AHBERR_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT13_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT13_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT13_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT13_TIMEOUT_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT13_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT13_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT13_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT13_INTKNTXFEMP_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT13_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT13_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT13_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT13_INTKNEPMIS_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT13_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT13_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT13_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT13_INEPNAKEFF_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT13_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT13_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT13_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT13_TXFEMP_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT13_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT13_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT13_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT13_TXFIFOUNDRN_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT13_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT13_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT13_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT13_BNAINTR_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT13_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT13_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT13_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT13_PKTDRPSTS_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT13_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT13_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT13_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT13_BBLEERR_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT13_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT13_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT13_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT13_NAKINTRPT_OFFSET 0xaa8 +#define GC_USB_DIEPINT13_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT13_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT13_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT13_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT13_NYETINTRPT_OFFSET 0xaa8 +#define GC_USB_DIEPTSIZ13_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ13_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ13_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ13_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ13_XFERSIZE_OFFSET 0xab0 +#define GC_USB_DIEPTSIZ13_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ13_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ13_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ13_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ13_PKTCNT_OFFSET 0xab0 +#define GC_USB_DIEPTSIZ13_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ13_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ13_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ13_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ13_MC_OFFSET 0xab0 +#define GC_USB_DIEPDMA13_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA13_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA13_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA13_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA13_DMAADDR_OFFSET 0xab4 +#define GC_USB_DTXFSTS13_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS13_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS13_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS13_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS13_INEPTXFSPCAVAIL_OFFSET 0xab8 +#define GC_USB_DIEPDMAB13_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB13_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB13_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB13_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB13_DMABUFFERADDR_OFFSET 0xabc +#define GC_USB_DIEPCTL14_MPS_LSB 0x0 +#define GC_USB_DIEPCTL14_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL14_MPS_SIZE 0xb +#define GC_USB_DIEPCTL14_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_MPS_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL14_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL14_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL14_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_USBACTEP_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_DPID_LSB 0x10 +#define GC_USB_DIEPCTL14_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL14_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL14_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_DPID_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL14_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL14_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL14_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_NAKSTS_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL14_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL14_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL14_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_EPTYPE_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_STALL_LSB 0x15 +#define GC_USB_DIEPCTL14_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL14_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL14_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_STALL_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL14_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL14_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL14_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_TXFNUM_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL14_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL14_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL14_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_CNAK_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL14_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL14_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL14_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_SNAK_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL14_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL14_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL14_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_SETD0PID_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL14_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL14_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL14_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_SETD1PID_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL14_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL14_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL14_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_EPDIS_OFFSET 0xac0 +#define GC_USB_DIEPCTL14_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL14_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL14_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL14_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL14_EPENA_OFFSET 0xac0 +#define GC_USB_DIEPINT14_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT14_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT14_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT14_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT14_XFERCOMPL_OFFSET 0xac8 +#define GC_USB_DIEPINT14_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT14_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT14_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT14_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT14_EPDISBLD_OFFSET 0xac8 +#define GC_USB_DIEPINT14_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT14_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT14_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT14_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT14_AHBERR_OFFSET 0xac8 +#define GC_USB_DIEPINT14_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT14_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT14_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT14_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT14_TIMEOUT_OFFSET 0xac8 +#define GC_USB_DIEPINT14_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT14_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT14_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT14_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT14_INTKNTXFEMP_OFFSET 0xac8 +#define GC_USB_DIEPINT14_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT14_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT14_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT14_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT14_INTKNEPMIS_OFFSET 0xac8 +#define GC_USB_DIEPINT14_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT14_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT14_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT14_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT14_INEPNAKEFF_OFFSET 0xac8 +#define GC_USB_DIEPINT14_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT14_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT14_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT14_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT14_TXFEMP_OFFSET 0xac8 +#define GC_USB_DIEPINT14_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT14_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT14_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT14_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT14_TXFIFOUNDRN_OFFSET 0xac8 +#define GC_USB_DIEPINT14_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT14_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT14_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT14_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT14_BNAINTR_OFFSET 0xac8 +#define GC_USB_DIEPINT14_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT14_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT14_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT14_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT14_PKTDRPSTS_OFFSET 0xac8 +#define GC_USB_DIEPINT14_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT14_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT14_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT14_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT14_BBLEERR_OFFSET 0xac8 +#define GC_USB_DIEPINT14_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT14_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT14_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT14_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT14_NAKINTRPT_OFFSET 0xac8 +#define GC_USB_DIEPINT14_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT14_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT14_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT14_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT14_NYETINTRPT_OFFSET 0xac8 +#define GC_USB_DIEPTSIZ14_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ14_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ14_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ14_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ14_XFERSIZE_OFFSET 0xad0 +#define GC_USB_DIEPTSIZ14_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ14_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ14_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ14_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ14_PKTCNT_OFFSET 0xad0 +#define GC_USB_DIEPTSIZ14_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ14_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ14_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ14_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ14_MC_OFFSET 0xad0 +#define GC_USB_DIEPDMA14_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA14_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA14_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA14_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA14_DMAADDR_OFFSET 0xad4 +#define GC_USB_DTXFSTS14_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS14_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS14_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS14_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS14_INEPTXFSPCAVAIL_OFFSET 0xad8 +#define GC_USB_DIEPDMAB14_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB14_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB14_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB14_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB14_DMABUFFERADDR_OFFSET 0xadc +#define GC_USB_DIEPCTL15_MPS_LSB 0x0 +#define GC_USB_DIEPCTL15_MPS_MASK 0x7ff +#define GC_USB_DIEPCTL15_MPS_SIZE 0xb +#define GC_USB_DIEPCTL15_MPS_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_MPS_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_USBACTEP_LSB 0xf +#define GC_USB_DIEPCTL15_USBACTEP_MASK 0x8000 +#define GC_USB_DIEPCTL15_USBACTEP_SIZE 0x1 +#define GC_USB_DIEPCTL15_USBACTEP_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_USBACTEP_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_DPID_LSB 0x10 +#define GC_USB_DIEPCTL15_DPID_MASK 0x10000 +#define GC_USB_DIEPCTL15_DPID_SIZE 0x1 +#define GC_USB_DIEPCTL15_DPID_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_DPID_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_NAKSTS_LSB 0x11 +#define GC_USB_DIEPCTL15_NAKSTS_MASK 0x20000 +#define GC_USB_DIEPCTL15_NAKSTS_SIZE 0x1 +#define GC_USB_DIEPCTL15_NAKSTS_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_NAKSTS_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_EPTYPE_LSB 0x12 +#define GC_USB_DIEPCTL15_EPTYPE_MASK 0xc0000 +#define GC_USB_DIEPCTL15_EPTYPE_SIZE 0x2 +#define GC_USB_DIEPCTL15_EPTYPE_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_EPTYPE_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_STALL_LSB 0x15 +#define GC_USB_DIEPCTL15_STALL_MASK 0x200000 +#define GC_USB_DIEPCTL15_STALL_SIZE 0x1 +#define GC_USB_DIEPCTL15_STALL_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_STALL_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_TXFNUM_LSB 0x16 +#define GC_USB_DIEPCTL15_TXFNUM_MASK 0x3c00000 +#define GC_USB_DIEPCTL15_TXFNUM_SIZE 0x4 +#define GC_USB_DIEPCTL15_TXFNUM_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_TXFNUM_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_CNAK_LSB 0x1a +#define GC_USB_DIEPCTL15_CNAK_MASK 0x4000000 +#define GC_USB_DIEPCTL15_CNAK_SIZE 0x1 +#define GC_USB_DIEPCTL15_CNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_CNAK_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_SNAK_LSB 0x1b +#define GC_USB_DIEPCTL15_SNAK_MASK 0x8000000 +#define GC_USB_DIEPCTL15_SNAK_SIZE 0x1 +#define GC_USB_DIEPCTL15_SNAK_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_SNAK_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_SETD0PID_LSB 0x1c +#define GC_USB_DIEPCTL15_SETD0PID_MASK 0x10000000 +#define GC_USB_DIEPCTL15_SETD0PID_SIZE 0x1 +#define GC_USB_DIEPCTL15_SETD0PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_SETD0PID_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_SETD1PID_LSB 0x1d +#define GC_USB_DIEPCTL15_SETD1PID_MASK 0x20000000 +#define GC_USB_DIEPCTL15_SETD1PID_SIZE 0x1 +#define GC_USB_DIEPCTL15_SETD1PID_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_SETD1PID_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_EPDIS_LSB 0x1e +#define GC_USB_DIEPCTL15_EPDIS_MASK 0x40000000 +#define GC_USB_DIEPCTL15_EPDIS_SIZE 0x1 +#define GC_USB_DIEPCTL15_EPDIS_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_EPDIS_OFFSET 0xae0 +#define GC_USB_DIEPCTL15_EPENA_LSB 0x1f +#define GC_USB_DIEPCTL15_EPENA_MASK 0x80000000 +#define GC_USB_DIEPCTL15_EPENA_SIZE 0x1 +#define GC_USB_DIEPCTL15_EPENA_DEFAULT 0x0 +#define GC_USB_DIEPCTL15_EPENA_OFFSET 0xae0 +#define GC_USB_DIEPINT15_XFERCOMPL_LSB 0x0 +#define GC_USB_DIEPINT15_XFERCOMPL_MASK 0x1 +#define GC_USB_DIEPINT15_XFERCOMPL_SIZE 0x1 +#define GC_USB_DIEPINT15_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DIEPINT15_XFERCOMPL_OFFSET 0xae8 +#define GC_USB_DIEPINT15_EPDISBLD_LSB 0x1 +#define GC_USB_DIEPINT15_EPDISBLD_MASK 0x2 +#define GC_USB_DIEPINT15_EPDISBLD_SIZE 0x1 +#define GC_USB_DIEPINT15_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DIEPINT15_EPDISBLD_OFFSET 0xae8 +#define GC_USB_DIEPINT15_AHBERR_LSB 0x2 +#define GC_USB_DIEPINT15_AHBERR_MASK 0x4 +#define GC_USB_DIEPINT15_AHBERR_SIZE 0x1 +#define GC_USB_DIEPINT15_AHBERR_DEFAULT 0x0 +#define GC_USB_DIEPINT15_AHBERR_OFFSET 0xae8 +#define GC_USB_DIEPINT15_TIMEOUT_LSB 0x3 +#define GC_USB_DIEPINT15_TIMEOUT_MASK 0x8 +#define GC_USB_DIEPINT15_TIMEOUT_SIZE 0x1 +#define GC_USB_DIEPINT15_TIMEOUT_DEFAULT 0x0 +#define GC_USB_DIEPINT15_TIMEOUT_OFFSET 0xae8 +#define GC_USB_DIEPINT15_INTKNTXFEMP_LSB 0x4 +#define GC_USB_DIEPINT15_INTKNTXFEMP_MASK 0x10 +#define GC_USB_DIEPINT15_INTKNTXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT15_INTKNTXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT15_INTKNTXFEMP_OFFSET 0xae8 +#define GC_USB_DIEPINT15_INTKNEPMIS_LSB 0x5 +#define GC_USB_DIEPINT15_INTKNEPMIS_MASK 0x20 +#define GC_USB_DIEPINT15_INTKNEPMIS_SIZE 0x1 +#define GC_USB_DIEPINT15_INTKNEPMIS_DEFAULT 0x0 +#define GC_USB_DIEPINT15_INTKNEPMIS_OFFSET 0xae8 +#define GC_USB_DIEPINT15_INEPNAKEFF_LSB 0x6 +#define GC_USB_DIEPINT15_INEPNAKEFF_MASK 0x40 +#define GC_USB_DIEPINT15_INEPNAKEFF_SIZE 0x1 +#define GC_USB_DIEPINT15_INEPNAKEFF_DEFAULT 0x0 +#define GC_USB_DIEPINT15_INEPNAKEFF_OFFSET 0xae8 +#define GC_USB_DIEPINT15_TXFEMP_LSB 0x7 +#define GC_USB_DIEPINT15_TXFEMP_MASK 0x80 +#define GC_USB_DIEPINT15_TXFEMP_SIZE 0x1 +#define GC_USB_DIEPINT15_TXFEMP_DEFAULT 0x0 +#define GC_USB_DIEPINT15_TXFEMP_OFFSET 0xae8 +#define GC_USB_DIEPINT15_TXFIFOUNDRN_LSB 0x8 +#define GC_USB_DIEPINT15_TXFIFOUNDRN_MASK 0x100 +#define GC_USB_DIEPINT15_TXFIFOUNDRN_SIZE 0x1 +#define GC_USB_DIEPINT15_TXFIFOUNDRN_DEFAULT 0x0 +#define GC_USB_DIEPINT15_TXFIFOUNDRN_OFFSET 0xae8 +#define GC_USB_DIEPINT15_BNAINTR_LSB 0x9 +#define GC_USB_DIEPINT15_BNAINTR_MASK 0x200 +#define GC_USB_DIEPINT15_BNAINTR_SIZE 0x1 +#define GC_USB_DIEPINT15_BNAINTR_DEFAULT 0x0 +#define GC_USB_DIEPINT15_BNAINTR_OFFSET 0xae8 +#define GC_USB_DIEPINT15_PKTDRPSTS_LSB 0xb +#define GC_USB_DIEPINT15_PKTDRPSTS_MASK 0x800 +#define GC_USB_DIEPINT15_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DIEPINT15_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DIEPINT15_PKTDRPSTS_OFFSET 0xae8 +#define GC_USB_DIEPINT15_BBLEERR_LSB 0xc +#define GC_USB_DIEPINT15_BBLEERR_MASK 0x1000 +#define GC_USB_DIEPINT15_BBLEERR_SIZE 0x1 +#define GC_USB_DIEPINT15_BBLEERR_DEFAULT 0x0 +#define GC_USB_DIEPINT15_BBLEERR_OFFSET 0xae8 +#define GC_USB_DIEPINT15_NAKINTRPT_LSB 0xd +#define GC_USB_DIEPINT15_NAKINTRPT_MASK 0x2000 +#define GC_USB_DIEPINT15_NAKINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT15_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT15_NAKINTRPT_OFFSET 0xae8 +#define GC_USB_DIEPINT15_NYETINTRPT_LSB 0xe +#define GC_USB_DIEPINT15_NYETINTRPT_MASK 0x4000 +#define GC_USB_DIEPINT15_NYETINTRPT_SIZE 0x1 +#define GC_USB_DIEPINT15_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DIEPINT15_NYETINTRPT_OFFSET 0xae8 +#define GC_USB_DIEPTSIZ15_XFERSIZE_LSB 0x0 +#define GC_USB_DIEPTSIZ15_XFERSIZE_MASK 0x7ffff +#define GC_USB_DIEPTSIZ15_XFERSIZE_SIZE 0x13 +#define GC_USB_DIEPTSIZ15_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ15_XFERSIZE_OFFSET 0xaf0 +#define GC_USB_DIEPTSIZ15_PKTCNT_LSB 0x13 +#define GC_USB_DIEPTSIZ15_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DIEPTSIZ15_PKTCNT_SIZE 0xa +#define GC_USB_DIEPTSIZ15_PKTCNT_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ15_PKTCNT_OFFSET 0xaf0 +#define GC_USB_DIEPTSIZ15_MC_LSB 0x1d +#define GC_USB_DIEPTSIZ15_MC_MASK 0x60000000 +#define GC_USB_DIEPTSIZ15_MC_SIZE 0x2 +#define GC_USB_DIEPTSIZ15_MC_DEFAULT 0x0 +#define GC_USB_DIEPTSIZ15_MC_OFFSET 0xaf0 +#define GC_USB_DIEPDMA15_DMAADDR_LSB 0x0 +#define GC_USB_DIEPDMA15_DMAADDR_MASK 0xffffffff +#define GC_USB_DIEPDMA15_DMAADDR_SIZE 0x20 +#define GC_USB_DIEPDMA15_DMAADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMA15_DMAADDR_OFFSET 0xaf4 +#define GC_USB_DTXFSTS15_INEPTXFSPCAVAIL_LSB 0x0 +#define GC_USB_DTXFSTS15_INEPTXFSPCAVAIL_MASK 0xffff +#define GC_USB_DTXFSTS15_INEPTXFSPCAVAIL_SIZE 0x10 +#define GC_USB_DTXFSTS15_INEPTXFSPCAVAIL_DEFAULT 0x0 +#define GC_USB_DTXFSTS15_INEPTXFSPCAVAIL_OFFSET 0xaf8 +#define GC_USB_DIEPDMAB15_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DIEPDMAB15_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DIEPDMAB15_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DIEPDMAB15_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DIEPDMAB15_DMABUFFERADDR_OFFSET 0xafc +#define GC_USB_DOEPCTL0_MPS_LSB 0x0 +#define GC_USB_DOEPCTL0_MPS_MASK 0x3 +#define GC_USB_DOEPCTL0_MPS_SIZE 0x2 +#define GC_USB_DOEPCTL0_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_MPS_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL0_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL0_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL0_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_USBACTEP_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL0_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL0_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL0_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_NAKSTS_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL0_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL0_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL0_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_EPTYPE_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_SNP_LSB 0x14 +#define GC_USB_DOEPCTL0_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL0_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL0_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_SNP_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_STALL_LSB 0x15 +#define GC_USB_DOEPCTL0_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL0_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL0_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_STALL_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL0_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL0_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL0_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_CNAK_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL0_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL0_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL0_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_SNAK_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL0_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL0_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL0_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_EPDIS_OFFSET 0xb00 +#define GC_USB_DOEPCTL0_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL0_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL0_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL0_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL0_EPENA_OFFSET 0xb00 +#define GC_USB_DOEPINT0_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT0_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT0_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT0_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT0_XFERCOMPL_OFFSET 0xb08 +#define GC_USB_DOEPINT0_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT0_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT0_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT0_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT0_EPDISBLD_OFFSET 0xb08 +#define GC_USB_DOEPINT0_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT0_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT0_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT0_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT0_AHBERR_OFFSET 0xb08 +#define GC_USB_DOEPINT0_SETUP_LSB 0x3 +#define GC_USB_DOEPINT0_SETUP_MASK 0x8 +#define GC_USB_DOEPINT0_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT0_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT0_SETUP_OFFSET 0xb08 +#define GC_USB_DOEPINT0_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT0_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT0_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT0_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT0_OUTTKNEPDIS_OFFSET 0xb08 +#define GC_USB_DOEPINT0_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT0_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT0_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT0_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT0_STSPHSERCVD_OFFSET 0xb08 +#define GC_USB_DOEPINT0_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT0_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT0_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT0_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT0_BACK2BACKSETUP_OFFSET 0xb08 +#define GC_USB_DOEPINT0_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT0_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT0_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT0_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT0_OUTPKTERR_OFFSET 0xb08 +#define GC_USB_DOEPINT0_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT0_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT0_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT0_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT0_BNAINTR_OFFSET 0xb08 +#define GC_USB_DOEPINT0_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT0_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT0_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT0_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT0_PKTDRPSTS_OFFSET 0xb08 +#define GC_USB_DOEPINT0_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT0_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT0_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT0_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT0_BBLEERR_OFFSET 0xb08 +#define GC_USB_DOEPINT0_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT0_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT0_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT0_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT0_NAKINTRPT_OFFSET 0xb08 +#define GC_USB_DOEPINT0_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT0_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT0_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT0_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT0_NYETINTRPT_OFFSET 0xb08 +#define GC_USB_DOEPINT0_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT0_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT0_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT0_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT0_STUPPKTRCVD_OFFSET 0xb08 +#define GC_USB_DOEPTSIZ0_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ0_XFERSIZE_MASK 0x7f +#define GC_USB_DOEPTSIZ0_XFERSIZE_SIZE 0x7 +#define GC_USB_DOEPTSIZ0_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ0_XFERSIZE_OFFSET 0xb10 +#define GC_USB_DOEPTSIZ0_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ0_PKTCNT_MASK 0x80000 +#define GC_USB_DOEPTSIZ0_PKTCNT_SIZE 0x1 +#define GC_USB_DOEPTSIZ0_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ0_PKTCNT_OFFSET 0xb10 +#define GC_USB_DOEPTSIZ0_SUPCNT_LSB 0x1d +#define GC_USB_DOEPTSIZ0_SUPCNT_MASK 0x60000000 +#define GC_USB_DOEPTSIZ0_SUPCNT_SIZE 0x2 +#define GC_USB_DOEPTSIZ0_SUPCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ0_SUPCNT_OFFSET 0xb10 +#define GC_USB_DOEPDMA0_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA0_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA0_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA0_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA0_DMAADDR_OFFSET 0xb14 +#define GC_USB_DOEPDMAB0_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB0_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB0_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB0_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB0_DMABUFFERADDR_OFFSET 0xb1c +#define GC_USB_DOEPCTL1_MPS_LSB 0x0 +#define GC_USB_DOEPCTL1_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL1_MPS_SIZE 0xb +#define GC_USB_DOEPCTL1_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_MPS_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL1_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL1_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL1_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_USBACTEP_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_DPID_LSB 0x10 +#define GC_USB_DOEPCTL1_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL1_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL1_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_DPID_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL1_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL1_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL1_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_NAKSTS_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL1_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL1_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL1_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_EPTYPE_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_SNP_LSB 0x14 +#define GC_USB_DOEPCTL1_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL1_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL1_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_SNP_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_STALL_LSB 0x15 +#define GC_USB_DOEPCTL1_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL1_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL1_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_STALL_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL1_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL1_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL1_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_CNAK_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL1_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL1_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL1_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_SNAK_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL1_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL1_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL1_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_SETD0PID_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL1_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL1_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL1_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_SETD1PID_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL1_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL1_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL1_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_EPDIS_OFFSET 0xb20 +#define GC_USB_DOEPCTL1_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL1_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL1_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL1_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL1_EPENA_OFFSET 0xb20 +#define GC_USB_DOEPINT1_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT1_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT1_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT1_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT1_XFERCOMPL_OFFSET 0xb28 +#define GC_USB_DOEPINT1_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT1_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT1_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT1_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT1_EPDISBLD_OFFSET 0xb28 +#define GC_USB_DOEPINT1_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT1_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT1_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT1_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT1_AHBERR_OFFSET 0xb28 +#define GC_USB_DOEPINT1_SETUP_LSB 0x3 +#define GC_USB_DOEPINT1_SETUP_MASK 0x8 +#define GC_USB_DOEPINT1_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT1_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT1_SETUP_OFFSET 0xb28 +#define GC_USB_DOEPINT1_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT1_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT1_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT1_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT1_OUTTKNEPDIS_OFFSET 0xb28 +#define GC_USB_DOEPINT1_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT1_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT1_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT1_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT1_STSPHSERCVD_OFFSET 0xb28 +#define GC_USB_DOEPINT1_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT1_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT1_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT1_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT1_BACK2BACKSETUP_OFFSET 0xb28 +#define GC_USB_DOEPINT1_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT1_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT1_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT1_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT1_OUTPKTERR_OFFSET 0xb28 +#define GC_USB_DOEPINT1_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT1_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT1_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT1_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT1_BNAINTR_OFFSET 0xb28 +#define GC_USB_DOEPINT1_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT1_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT1_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT1_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT1_PKTDRPSTS_OFFSET 0xb28 +#define GC_USB_DOEPINT1_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT1_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT1_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT1_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT1_BBLEERR_OFFSET 0xb28 +#define GC_USB_DOEPINT1_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT1_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT1_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT1_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT1_NAKINTRPT_OFFSET 0xb28 +#define GC_USB_DOEPINT1_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT1_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT1_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT1_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT1_NYETINTRPT_OFFSET 0xb28 +#define GC_USB_DOEPINT1_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT1_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT1_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT1_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT1_STUPPKTRCVD_OFFSET 0xb28 +#define GC_USB_DOEPTSIZ1_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ1_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ1_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ1_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ1_XFERSIZE_OFFSET 0xb30 +#define GC_USB_DOEPTSIZ1_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ1_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ1_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ1_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ1_PKTCNT_OFFSET 0xb30 +#define GC_USB_DOEPTSIZ1_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ1_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ1_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ1_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ1_RXDPID_OFFSET 0xb30 +#define GC_USB_DOEPDMA1_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA1_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA1_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA1_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA1_DMAADDR_OFFSET 0xb34 +#define GC_USB_DOEPDMAB1_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB1_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB1_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB1_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB1_DMABUFFERADDR_OFFSET 0xb3c +#define GC_USB_DOEPCTL2_MPS_LSB 0x0 +#define GC_USB_DOEPCTL2_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL2_MPS_SIZE 0xb +#define GC_USB_DOEPCTL2_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_MPS_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL2_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL2_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL2_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_USBACTEP_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_DPID_LSB 0x10 +#define GC_USB_DOEPCTL2_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL2_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL2_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_DPID_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL2_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL2_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL2_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_NAKSTS_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL2_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL2_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL2_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_EPTYPE_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_SNP_LSB 0x14 +#define GC_USB_DOEPCTL2_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL2_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL2_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_SNP_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_STALL_LSB 0x15 +#define GC_USB_DOEPCTL2_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL2_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL2_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_STALL_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL2_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL2_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL2_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_CNAK_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL2_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL2_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL2_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_SNAK_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL2_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL2_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL2_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_SETD0PID_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL2_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL2_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL2_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_SETD1PID_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL2_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL2_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL2_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_EPDIS_OFFSET 0xb40 +#define GC_USB_DOEPCTL2_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL2_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL2_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL2_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL2_EPENA_OFFSET 0xb40 +#define GC_USB_DOEPINT2_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT2_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT2_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT2_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT2_XFERCOMPL_OFFSET 0xb48 +#define GC_USB_DOEPINT2_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT2_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT2_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT2_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT2_EPDISBLD_OFFSET 0xb48 +#define GC_USB_DOEPINT2_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT2_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT2_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT2_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT2_AHBERR_OFFSET 0xb48 +#define GC_USB_DOEPINT2_SETUP_LSB 0x3 +#define GC_USB_DOEPINT2_SETUP_MASK 0x8 +#define GC_USB_DOEPINT2_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT2_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT2_SETUP_OFFSET 0xb48 +#define GC_USB_DOEPINT2_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT2_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT2_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT2_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT2_OUTTKNEPDIS_OFFSET 0xb48 +#define GC_USB_DOEPINT2_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT2_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT2_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT2_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT2_STSPHSERCVD_OFFSET 0xb48 +#define GC_USB_DOEPINT2_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT2_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT2_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT2_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT2_BACK2BACKSETUP_OFFSET 0xb48 +#define GC_USB_DOEPINT2_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT2_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT2_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT2_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT2_OUTPKTERR_OFFSET 0xb48 +#define GC_USB_DOEPINT2_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT2_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT2_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT2_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT2_BNAINTR_OFFSET 0xb48 +#define GC_USB_DOEPINT2_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT2_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT2_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT2_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT2_PKTDRPSTS_OFFSET 0xb48 +#define GC_USB_DOEPINT2_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT2_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT2_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT2_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT2_BBLEERR_OFFSET 0xb48 +#define GC_USB_DOEPINT2_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT2_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT2_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT2_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT2_NAKINTRPT_OFFSET 0xb48 +#define GC_USB_DOEPINT2_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT2_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT2_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT2_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT2_NYETINTRPT_OFFSET 0xb48 +#define GC_USB_DOEPINT2_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT2_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT2_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT2_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT2_STUPPKTRCVD_OFFSET 0xb48 +#define GC_USB_DOEPTSIZ2_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ2_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ2_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ2_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ2_XFERSIZE_OFFSET 0xb50 +#define GC_USB_DOEPTSIZ2_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ2_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ2_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ2_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ2_PKTCNT_OFFSET 0xb50 +#define GC_USB_DOEPTSIZ2_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ2_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ2_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ2_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ2_RXDPID_OFFSET 0xb50 +#define GC_USB_DOEPDMA2_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA2_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA2_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA2_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA2_DMAADDR_OFFSET 0xb54 +#define GC_USB_DOEPDMAB2_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB2_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB2_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB2_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB2_DMABUFFERADDR_OFFSET 0xb5c +#define GC_USB_DOEPCTL3_MPS_LSB 0x0 +#define GC_USB_DOEPCTL3_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL3_MPS_SIZE 0xb +#define GC_USB_DOEPCTL3_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_MPS_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL3_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL3_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL3_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_USBACTEP_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_DPID_LSB 0x10 +#define GC_USB_DOEPCTL3_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL3_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL3_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_DPID_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL3_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL3_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL3_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_NAKSTS_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL3_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL3_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL3_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_EPTYPE_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_SNP_LSB 0x14 +#define GC_USB_DOEPCTL3_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL3_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL3_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_SNP_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_STALL_LSB 0x15 +#define GC_USB_DOEPCTL3_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL3_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL3_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_STALL_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL3_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL3_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL3_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_CNAK_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL3_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL3_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL3_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_SNAK_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL3_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL3_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL3_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_SETD0PID_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL3_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL3_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL3_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_SETD1PID_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL3_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL3_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL3_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_EPDIS_OFFSET 0xb60 +#define GC_USB_DOEPCTL3_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL3_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL3_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL3_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL3_EPENA_OFFSET 0xb60 +#define GC_USB_DOEPINT3_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT3_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT3_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT3_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT3_XFERCOMPL_OFFSET 0xb68 +#define GC_USB_DOEPINT3_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT3_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT3_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT3_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT3_EPDISBLD_OFFSET 0xb68 +#define GC_USB_DOEPINT3_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT3_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT3_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT3_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT3_AHBERR_OFFSET 0xb68 +#define GC_USB_DOEPINT3_SETUP_LSB 0x3 +#define GC_USB_DOEPINT3_SETUP_MASK 0x8 +#define GC_USB_DOEPINT3_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT3_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT3_SETUP_OFFSET 0xb68 +#define GC_USB_DOEPINT3_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT3_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT3_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT3_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT3_OUTTKNEPDIS_OFFSET 0xb68 +#define GC_USB_DOEPINT3_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT3_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT3_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT3_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT3_STSPHSERCVD_OFFSET 0xb68 +#define GC_USB_DOEPINT3_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT3_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT3_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT3_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT3_BACK2BACKSETUP_OFFSET 0xb68 +#define GC_USB_DOEPINT3_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT3_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT3_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT3_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT3_OUTPKTERR_OFFSET 0xb68 +#define GC_USB_DOEPINT3_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT3_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT3_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT3_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT3_BNAINTR_OFFSET 0xb68 +#define GC_USB_DOEPINT3_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT3_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT3_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT3_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT3_PKTDRPSTS_OFFSET 0xb68 +#define GC_USB_DOEPINT3_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT3_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT3_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT3_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT3_BBLEERR_OFFSET 0xb68 +#define GC_USB_DOEPINT3_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT3_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT3_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT3_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT3_NAKINTRPT_OFFSET 0xb68 +#define GC_USB_DOEPINT3_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT3_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT3_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT3_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT3_NYETINTRPT_OFFSET 0xb68 +#define GC_USB_DOEPINT3_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT3_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT3_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT3_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT3_STUPPKTRCVD_OFFSET 0xb68 +#define GC_USB_DOEPTSIZ3_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ3_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ3_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ3_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ3_XFERSIZE_OFFSET 0xb70 +#define GC_USB_DOEPTSIZ3_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ3_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ3_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ3_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ3_PKTCNT_OFFSET 0xb70 +#define GC_USB_DOEPTSIZ3_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ3_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ3_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ3_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ3_RXDPID_OFFSET 0xb70 +#define GC_USB_DOEPDMA3_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA3_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA3_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA3_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA3_DMAADDR_OFFSET 0xb74 +#define GC_USB_DOEPDMAB3_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB3_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB3_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB3_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB3_DMABUFFERADDR_OFFSET 0xb7c +#define GC_USB_DOEPCTL4_MPS_LSB 0x0 +#define GC_USB_DOEPCTL4_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL4_MPS_SIZE 0xb +#define GC_USB_DOEPCTL4_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_MPS_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL4_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL4_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL4_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_USBACTEP_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_DPID_LSB 0x10 +#define GC_USB_DOEPCTL4_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL4_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL4_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_DPID_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL4_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL4_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL4_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_NAKSTS_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL4_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL4_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL4_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_EPTYPE_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_SNP_LSB 0x14 +#define GC_USB_DOEPCTL4_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL4_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL4_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_SNP_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_STALL_LSB 0x15 +#define GC_USB_DOEPCTL4_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL4_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL4_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_STALL_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL4_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL4_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL4_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_CNAK_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL4_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL4_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL4_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_SNAK_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL4_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL4_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL4_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_SETD0PID_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL4_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL4_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL4_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_SETD1PID_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL4_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL4_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL4_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_EPDIS_OFFSET 0xb80 +#define GC_USB_DOEPCTL4_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL4_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL4_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL4_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL4_EPENA_OFFSET 0xb80 +#define GC_USB_DOEPINT4_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT4_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT4_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT4_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT4_XFERCOMPL_OFFSET 0xb88 +#define GC_USB_DOEPINT4_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT4_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT4_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT4_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT4_EPDISBLD_OFFSET 0xb88 +#define GC_USB_DOEPINT4_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT4_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT4_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT4_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT4_AHBERR_OFFSET 0xb88 +#define GC_USB_DOEPINT4_SETUP_LSB 0x3 +#define GC_USB_DOEPINT4_SETUP_MASK 0x8 +#define GC_USB_DOEPINT4_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT4_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT4_SETUP_OFFSET 0xb88 +#define GC_USB_DOEPINT4_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT4_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT4_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT4_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT4_OUTTKNEPDIS_OFFSET 0xb88 +#define GC_USB_DOEPINT4_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT4_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT4_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT4_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT4_STSPHSERCVD_OFFSET 0xb88 +#define GC_USB_DOEPINT4_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT4_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT4_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT4_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT4_BACK2BACKSETUP_OFFSET 0xb88 +#define GC_USB_DOEPINT4_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT4_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT4_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT4_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT4_OUTPKTERR_OFFSET 0xb88 +#define GC_USB_DOEPINT4_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT4_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT4_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT4_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT4_BNAINTR_OFFSET 0xb88 +#define GC_USB_DOEPINT4_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT4_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT4_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT4_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT4_PKTDRPSTS_OFFSET 0xb88 +#define GC_USB_DOEPINT4_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT4_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT4_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT4_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT4_BBLEERR_OFFSET 0xb88 +#define GC_USB_DOEPINT4_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT4_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT4_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT4_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT4_NAKINTRPT_OFFSET 0xb88 +#define GC_USB_DOEPINT4_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT4_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT4_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT4_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT4_NYETINTRPT_OFFSET 0xb88 +#define GC_USB_DOEPINT4_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT4_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT4_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT4_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT4_STUPPKTRCVD_OFFSET 0xb88 +#define GC_USB_DOEPTSIZ4_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ4_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ4_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ4_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ4_XFERSIZE_OFFSET 0xb90 +#define GC_USB_DOEPTSIZ4_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ4_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ4_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ4_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ4_PKTCNT_OFFSET 0xb90 +#define GC_USB_DOEPTSIZ4_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ4_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ4_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ4_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ4_RXDPID_OFFSET 0xb90 +#define GC_USB_DOEPDMA4_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA4_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA4_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA4_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA4_DMAADDR_OFFSET 0xb94 +#define GC_USB_DOEPDMAB4_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB4_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB4_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB4_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB4_DMABUFFERADDR_OFFSET 0xb9c +#define GC_USB_DOEPCTL5_MPS_LSB 0x0 +#define GC_USB_DOEPCTL5_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL5_MPS_SIZE 0xb +#define GC_USB_DOEPCTL5_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_MPS_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL5_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL5_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL5_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_USBACTEP_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_DPID_LSB 0x10 +#define GC_USB_DOEPCTL5_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL5_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL5_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_DPID_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL5_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL5_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL5_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_NAKSTS_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL5_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL5_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL5_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_EPTYPE_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_SNP_LSB 0x14 +#define GC_USB_DOEPCTL5_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL5_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL5_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_SNP_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_STALL_LSB 0x15 +#define GC_USB_DOEPCTL5_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL5_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL5_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_STALL_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL5_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL5_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL5_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_CNAK_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL5_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL5_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL5_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_SNAK_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL5_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL5_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL5_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_SETD0PID_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL5_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL5_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL5_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_SETD1PID_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL5_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL5_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL5_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_EPDIS_OFFSET 0xba0 +#define GC_USB_DOEPCTL5_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL5_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL5_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL5_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL5_EPENA_OFFSET 0xba0 +#define GC_USB_DOEPINT5_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT5_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT5_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT5_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT5_XFERCOMPL_OFFSET 0xba8 +#define GC_USB_DOEPINT5_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT5_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT5_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT5_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT5_EPDISBLD_OFFSET 0xba8 +#define GC_USB_DOEPINT5_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT5_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT5_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT5_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT5_AHBERR_OFFSET 0xba8 +#define GC_USB_DOEPINT5_SETUP_LSB 0x3 +#define GC_USB_DOEPINT5_SETUP_MASK 0x8 +#define GC_USB_DOEPINT5_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT5_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT5_SETUP_OFFSET 0xba8 +#define GC_USB_DOEPINT5_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT5_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT5_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT5_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT5_OUTTKNEPDIS_OFFSET 0xba8 +#define GC_USB_DOEPINT5_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT5_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT5_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT5_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT5_STSPHSERCVD_OFFSET 0xba8 +#define GC_USB_DOEPINT5_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT5_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT5_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT5_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT5_BACK2BACKSETUP_OFFSET 0xba8 +#define GC_USB_DOEPINT5_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT5_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT5_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT5_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT5_OUTPKTERR_OFFSET 0xba8 +#define GC_USB_DOEPINT5_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT5_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT5_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT5_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT5_BNAINTR_OFFSET 0xba8 +#define GC_USB_DOEPINT5_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT5_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT5_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT5_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT5_PKTDRPSTS_OFFSET 0xba8 +#define GC_USB_DOEPINT5_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT5_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT5_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT5_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT5_BBLEERR_OFFSET 0xba8 +#define GC_USB_DOEPINT5_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT5_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT5_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT5_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT5_NAKINTRPT_OFFSET 0xba8 +#define GC_USB_DOEPINT5_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT5_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT5_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT5_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT5_NYETINTRPT_OFFSET 0xba8 +#define GC_USB_DOEPINT5_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT5_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT5_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT5_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT5_STUPPKTRCVD_OFFSET 0xba8 +#define GC_USB_DOEPTSIZ5_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ5_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ5_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ5_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ5_XFERSIZE_OFFSET 0xbb0 +#define GC_USB_DOEPTSIZ5_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ5_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ5_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ5_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ5_PKTCNT_OFFSET 0xbb0 +#define GC_USB_DOEPTSIZ5_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ5_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ5_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ5_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ5_RXDPID_OFFSET 0xbb0 +#define GC_USB_DOEPDMA5_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA5_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA5_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA5_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA5_DMAADDR_OFFSET 0xbb4 +#define GC_USB_DOEPDMAB5_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB5_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB5_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB5_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB5_DMABUFFERADDR_OFFSET 0xbbc +#define GC_USB_DOEPCTL6_MPS_LSB 0x0 +#define GC_USB_DOEPCTL6_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL6_MPS_SIZE 0xb +#define GC_USB_DOEPCTL6_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_MPS_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL6_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL6_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL6_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_USBACTEP_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_DPID_LSB 0x10 +#define GC_USB_DOEPCTL6_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL6_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL6_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_DPID_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL6_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL6_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL6_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_NAKSTS_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL6_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL6_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL6_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_EPTYPE_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_SNP_LSB 0x14 +#define GC_USB_DOEPCTL6_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL6_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL6_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_SNP_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_STALL_LSB 0x15 +#define GC_USB_DOEPCTL6_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL6_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL6_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_STALL_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL6_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL6_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL6_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_CNAK_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL6_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL6_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL6_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_SNAK_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL6_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL6_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL6_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_SETD0PID_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL6_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL6_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL6_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_SETD1PID_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL6_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL6_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL6_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_EPDIS_OFFSET 0xbc0 +#define GC_USB_DOEPCTL6_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL6_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL6_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL6_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL6_EPENA_OFFSET 0xbc0 +#define GC_USB_DOEPINT6_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT6_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT6_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT6_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT6_XFERCOMPL_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT6_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT6_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT6_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT6_EPDISBLD_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT6_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT6_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT6_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT6_AHBERR_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_SETUP_LSB 0x3 +#define GC_USB_DOEPINT6_SETUP_MASK 0x8 +#define GC_USB_DOEPINT6_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT6_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT6_SETUP_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT6_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT6_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT6_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT6_OUTTKNEPDIS_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT6_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT6_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT6_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT6_STSPHSERCVD_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT6_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT6_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT6_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT6_BACK2BACKSETUP_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT6_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT6_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT6_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT6_OUTPKTERR_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT6_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT6_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT6_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT6_BNAINTR_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT6_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT6_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT6_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT6_PKTDRPSTS_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT6_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT6_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT6_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT6_BBLEERR_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT6_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT6_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT6_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT6_NAKINTRPT_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT6_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT6_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT6_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT6_NYETINTRPT_OFFSET 0xbc8 +#define GC_USB_DOEPINT6_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT6_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT6_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT6_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT6_STUPPKTRCVD_OFFSET 0xbc8 +#define GC_USB_DOEPTSIZ6_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ6_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ6_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ6_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ6_XFERSIZE_OFFSET 0xbd0 +#define GC_USB_DOEPTSIZ6_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ6_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ6_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ6_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ6_PKTCNT_OFFSET 0xbd0 +#define GC_USB_DOEPTSIZ6_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ6_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ6_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ6_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ6_RXDPID_OFFSET 0xbd0 +#define GC_USB_DOEPDMA6_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA6_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA6_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA6_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA6_DMAADDR_OFFSET 0xbd4 +#define GC_USB_DOEPDMAB6_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB6_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB6_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB6_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB6_DMABUFFERADDR_OFFSET 0xbdc +#define GC_USB_DOEPCTL7_MPS_LSB 0x0 +#define GC_USB_DOEPCTL7_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL7_MPS_SIZE 0xb +#define GC_USB_DOEPCTL7_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_MPS_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL7_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL7_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL7_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_USBACTEP_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_DPID_LSB 0x10 +#define GC_USB_DOEPCTL7_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL7_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL7_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_DPID_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL7_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL7_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL7_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_NAKSTS_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL7_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL7_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL7_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_EPTYPE_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_SNP_LSB 0x14 +#define GC_USB_DOEPCTL7_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL7_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL7_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_SNP_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_STALL_LSB 0x15 +#define GC_USB_DOEPCTL7_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL7_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL7_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_STALL_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL7_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL7_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL7_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_CNAK_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL7_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL7_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL7_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_SNAK_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL7_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL7_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL7_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_SETD0PID_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL7_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL7_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL7_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_SETD1PID_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL7_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL7_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL7_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_EPDIS_OFFSET 0xbe0 +#define GC_USB_DOEPCTL7_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL7_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL7_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL7_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL7_EPENA_OFFSET 0xbe0 +#define GC_USB_DOEPINT7_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT7_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT7_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT7_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT7_XFERCOMPL_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT7_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT7_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT7_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT7_EPDISBLD_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT7_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT7_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT7_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT7_AHBERR_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_SETUP_LSB 0x3 +#define GC_USB_DOEPINT7_SETUP_MASK 0x8 +#define GC_USB_DOEPINT7_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT7_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT7_SETUP_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT7_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT7_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT7_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT7_OUTTKNEPDIS_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT7_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT7_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT7_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT7_STSPHSERCVD_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT7_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT7_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT7_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT7_BACK2BACKSETUP_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT7_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT7_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT7_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT7_OUTPKTERR_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT7_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT7_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT7_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT7_BNAINTR_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT7_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT7_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT7_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT7_PKTDRPSTS_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT7_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT7_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT7_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT7_BBLEERR_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT7_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT7_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT7_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT7_NAKINTRPT_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT7_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT7_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT7_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT7_NYETINTRPT_OFFSET 0xbe8 +#define GC_USB_DOEPINT7_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT7_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT7_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT7_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT7_STUPPKTRCVD_OFFSET 0xbe8 +#define GC_USB_DOEPTSIZ7_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ7_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ7_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ7_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ7_XFERSIZE_OFFSET 0xbf0 +#define GC_USB_DOEPTSIZ7_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ7_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ7_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ7_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ7_PKTCNT_OFFSET 0xbf0 +#define GC_USB_DOEPTSIZ7_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ7_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ7_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ7_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ7_RXDPID_OFFSET 0xbf0 +#define GC_USB_DOEPDMA7_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA7_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA7_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA7_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA7_DMAADDR_OFFSET 0xbf4 +#define GC_USB_DOEPDMAB7_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB7_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB7_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB7_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB7_DMABUFFERADDR_OFFSET 0xbfc +#define GC_USB_DOEPCTL8_MPS_LSB 0x0 +#define GC_USB_DOEPCTL8_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL8_MPS_SIZE 0xb +#define GC_USB_DOEPCTL8_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_MPS_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL8_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL8_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL8_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_USBACTEP_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_DPID_LSB 0x10 +#define GC_USB_DOEPCTL8_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL8_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL8_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_DPID_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL8_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL8_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL8_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_NAKSTS_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL8_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL8_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL8_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_EPTYPE_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_SNP_LSB 0x14 +#define GC_USB_DOEPCTL8_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL8_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL8_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_SNP_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_STALL_LSB 0x15 +#define GC_USB_DOEPCTL8_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL8_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL8_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_STALL_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL8_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL8_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL8_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_CNAK_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL8_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL8_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL8_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_SNAK_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL8_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL8_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL8_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_SETD0PID_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL8_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL8_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL8_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_SETD1PID_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL8_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL8_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL8_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_EPDIS_OFFSET 0xc00 +#define GC_USB_DOEPCTL8_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL8_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL8_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL8_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL8_EPENA_OFFSET 0xc00 +#define GC_USB_DOEPINT8_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT8_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT8_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT8_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT8_XFERCOMPL_OFFSET 0xc08 +#define GC_USB_DOEPINT8_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT8_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT8_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT8_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT8_EPDISBLD_OFFSET 0xc08 +#define GC_USB_DOEPINT8_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT8_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT8_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT8_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT8_AHBERR_OFFSET 0xc08 +#define GC_USB_DOEPINT8_SETUP_LSB 0x3 +#define GC_USB_DOEPINT8_SETUP_MASK 0x8 +#define GC_USB_DOEPINT8_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT8_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT8_SETUP_OFFSET 0xc08 +#define GC_USB_DOEPINT8_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT8_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT8_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT8_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT8_OUTTKNEPDIS_OFFSET 0xc08 +#define GC_USB_DOEPINT8_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT8_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT8_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT8_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT8_STSPHSERCVD_OFFSET 0xc08 +#define GC_USB_DOEPINT8_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT8_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT8_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT8_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT8_BACK2BACKSETUP_OFFSET 0xc08 +#define GC_USB_DOEPINT8_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT8_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT8_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT8_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT8_OUTPKTERR_OFFSET 0xc08 +#define GC_USB_DOEPINT8_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT8_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT8_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT8_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT8_BNAINTR_OFFSET 0xc08 +#define GC_USB_DOEPINT8_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT8_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT8_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT8_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT8_PKTDRPSTS_OFFSET 0xc08 +#define GC_USB_DOEPINT8_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT8_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT8_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT8_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT8_BBLEERR_OFFSET 0xc08 +#define GC_USB_DOEPINT8_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT8_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT8_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT8_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT8_NAKINTRPT_OFFSET 0xc08 +#define GC_USB_DOEPINT8_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT8_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT8_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT8_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT8_NYETINTRPT_OFFSET 0xc08 +#define GC_USB_DOEPINT8_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT8_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT8_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT8_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT8_STUPPKTRCVD_OFFSET 0xc08 +#define GC_USB_DOEPTSIZ8_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ8_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ8_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ8_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ8_XFERSIZE_OFFSET 0xc10 +#define GC_USB_DOEPTSIZ8_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ8_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ8_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ8_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ8_PKTCNT_OFFSET 0xc10 +#define GC_USB_DOEPTSIZ8_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ8_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ8_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ8_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ8_RXDPID_OFFSET 0xc10 +#define GC_USB_DOEPDMA8_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA8_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA8_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA8_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA8_DMAADDR_OFFSET 0xc14 +#define GC_USB_DOEPDMAB8_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB8_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB8_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB8_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB8_DMABUFFERADDR_OFFSET 0xc1c +#define GC_USB_DOEPCTL9_MPS_LSB 0x0 +#define GC_USB_DOEPCTL9_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL9_MPS_SIZE 0xb +#define GC_USB_DOEPCTL9_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_MPS_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL9_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL9_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL9_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_USBACTEP_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_DPID_LSB 0x10 +#define GC_USB_DOEPCTL9_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL9_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL9_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_DPID_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL9_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL9_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL9_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_NAKSTS_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL9_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL9_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL9_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_EPTYPE_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_SNP_LSB 0x14 +#define GC_USB_DOEPCTL9_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL9_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL9_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_SNP_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_STALL_LSB 0x15 +#define GC_USB_DOEPCTL9_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL9_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL9_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_STALL_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL9_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL9_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL9_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_CNAK_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL9_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL9_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL9_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_SNAK_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL9_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL9_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL9_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_SETD0PID_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL9_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL9_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL9_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_SETD1PID_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL9_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL9_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL9_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_EPDIS_OFFSET 0xc20 +#define GC_USB_DOEPCTL9_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL9_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL9_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL9_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL9_EPENA_OFFSET 0xc20 +#define GC_USB_DOEPINT9_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT9_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT9_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT9_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT9_XFERCOMPL_OFFSET 0xc28 +#define GC_USB_DOEPINT9_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT9_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT9_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT9_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT9_EPDISBLD_OFFSET 0xc28 +#define GC_USB_DOEPINT9_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT9_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT9_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT9_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT9_AHBERR_OFFSET 0xc28 +#define GC_USB_DOEPINT9_SETUP_LSB 0x3 +#define GC_USB_DOEPINT9_SETUP_MASK 0x8 +#define GC_USB_DOEPINT9_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT9_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT9_SETUP_OFFSET 0xc28 +#define GC_USB_DOEPINT9_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT9_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT9_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT9_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT9_OUTTKNEPDIS_OFFSET 0xc28 +#define GC_USB_DOEPINT9_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT9_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT9_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT9_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT9_STSPHSERCVD_OFFSET 0xc28 +#define GC_USB_DOEPINT9_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT9_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT9_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT9_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT9_BACK2BACKSETUP_OFFSET 0xc28 +#define GC_USB_DOEPINT9_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT9_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT9_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT9_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT9_OUTPKTERR_OFFSET 0xc28 +#define GC_USB_DOEPINT9_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT9_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT9_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT9_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT9_BNAINTR_OFFSET 0xc28 +#define GC_USB_DOEPINT9_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT9_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT9_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT9_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT9_PKTDRPSTS_OFFSET 0xc28 +#define GC_USB_DOEPINT9_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT9_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT9_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT9_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT9_BBLEERR_OFFSET 0xc28 +#define GC_USB_DOEPINT9_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT9_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT9_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT9_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT9_NAKINTRPT_OFFSET 0xc28 +#define GC_USB_DOEPINT9_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT9_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT9_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT9_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT9_NYETINTRPT_OFFSET 0xc28 +#define GC_USB_DOEPINT9_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT9_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT9_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT9_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT9_STUPPKTRCVD_OFFSET 0xc28 +#define GC_USB_DOEPTSIZ9_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ9_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ9_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ9_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ9_XFERSIZE_OFFSET 0xc30 +#define GC_USB_DOEPTSIZ9_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ9_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ9_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ9_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ9_PKTCNT_OFFSET 0xc30 +#define GC_USB_DOEPTSIZ9_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ9_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ9_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ9_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ9_RXDPID_OFFSET 0xc30 +#define GC_USB_DOEPDMA9_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA9_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA9_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA9_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA9_DMAADDR_OFFSET 0xc34 +#define GC_USB_DOEPDMAB9_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB9_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB9_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB9_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB9_DMABUFFERADDR_OFFSET 0xc3c +#define GC_USB_DOEPCTL10_MPS_LSB 0x0 +#define GC_USB_DOEPCTL10_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL10_MPS_SIZE 0xb +#define GC_USB_DOEPCTL10_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_MPS_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL10_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL10_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL10_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_USBACTEP_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_DPID_LSB 0x10 +#define GC_USB_DOEPCTL10_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL10_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL10_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_DPID_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL10_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL10_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL10_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_NAKSTS_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL10_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL10_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL10_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_EPTYPE_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_SNP_LSB 0x14 +#define GC_USB_DOEPCTL10_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL10_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL10_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_SNP_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_STALL_LSB 0x15 +#define GC_USB_DOEPCTL10_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL10_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL10_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_STALL_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL10_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL10_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL10_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_CNAK_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL10_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL10_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL10_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_SNAK_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL10_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL10_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL10_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_SETD0PID_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL10_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL10_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL10_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_SETD1PID_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL10_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL10_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL10_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_EPDIS_OFFSET 0xc40 +#define GC_USB_DOEPCTL10_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL10_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL10_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL10_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL10_EPENA_OFFSET 0xc40 +#define GC_USB_DOEPINT10_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT10_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT10_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT10_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT10_XFERCOMPL_OFFSET 0xc48 +#define GC_USB_DOEPINT10_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT10_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT10_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT10_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT10_EPDISBLD_OFFSET 0xc48 +#define GC_USB_DOEPINT10_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT10_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT10_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT10_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT10_AHBERR_OFFSET 0xc48 +#define GC_USB_DOEPINT10_SETUP_LSB 0x3 +#define GC_USB_DOEPINT10_SETUP_MASK 0x8 +#define GC_USB_DOEPINT10_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT10_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT10_SETUP_OFFSET 0xc48 +#define GC_USB_DOEPINT10_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT10_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT10_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT10_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT10_OUTTKNEPDIS_OFFSET 0xc48 +#define GC_USB_DOEPINT10_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT10_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT10_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT10_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT10_STSPHSERCVD_OFFSET 0xc48 +#define GC_USB_DOEPINT10_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT10_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT10_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT10_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT10_BACK2BACKSETUP_OFFSET 0xc48 +#define GC_USB_DOEPINT10_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT10_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT10_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT10_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT10_OUTPKTERR_OFFSET 0xc48 +#define GC_USB_DOEPINT10_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT10_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT10_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT10_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT10_BNAINTR_OFFSET 0xc48 +#define GC_USB_DOEPINT10_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT10_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT10_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT10_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT10_PKTDRPSTS_OFFSET 0xc48 +#define GC_USB_DOEPINT10_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT10_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT10_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT10_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT10_BBLEERR_OFFSET 0xc48 +#define GC_USB_DOEPINT10_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT10_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT10_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT10_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT10_NAKINTRPT_OFFSET 0xc48 +#define GC_USB_DOEPINT10_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT10_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT10_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT10_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT10_NYETINTRPT_OFFSET 0xc48 +#define GC_USB_DOEPINT10_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT10_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT10_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT10_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT10_STUPPKTRCVD_OFFSET 0xc48 +#define GC_USB_DOEPTSIZ10_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ10_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ10_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ10_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ10_XFERSIZE_OFFSET 0xc50 +#define GC_USB_DOEPTSIZ10_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ10_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ10_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ10_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ10_PKTCNT_OFFSET 0xc50 +#define GC_USB_DOEPTSIZ10_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ10_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ10_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ10_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ10_RXDPID_OFFSET 0xc50 +#define GC_USB_DOEPDMA10_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA10_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA10_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA10_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA10_DMAADDR_OFFSET 0xc54 +#define GC_USB_DOEPDMAB10_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB10_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB10_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB10_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB10_DMABUFFERADDR_OFFSET 0xc5c +#define GC_USB_DOEPCTL11_MPS_LSB 0x0 +#define GC_USB_DOEPCTL11_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL11_MPS_SIZE 0xb +#define GC_USB_DOEPCTL11_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_MPS_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL11_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL11_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL11_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_USBACTEP_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_DPID_LSB 0x10 +#define GC_USB_DOEPCTL11_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL11_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL11_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_DPID_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL11_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL11_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL11_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_NAKSTS_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL11_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL11_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL11_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_EPTYPE_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_SNP_LSB 0x14 +#define GC_USB_DOEPCTL11_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL11_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL11_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_SNP_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_STALL_LSB 0x15 +#define GC_USB_DOEPCTL11_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL11_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL11_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_STALL_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL11_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL11_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL11_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_CNAK_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL11_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL11_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL11_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_SNAK_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL11_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL11_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL11_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_SETD0PID_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL11_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL11_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL11_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_SETD1PID_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL11_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL11_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL11_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_EPDIS_OFFSET 0xc60 +#define GC_USB_DOEPCTL11_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL11_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL11_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL11_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL11_EPENA_OFFSET 0xc60 +#define GC_USB_DOEPINT11_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT11_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT11_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT11_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT11_XFERCOMPL_OFFSET 0xc68 +#define GC_USB_DOEPINT11_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT11_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT11_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT11_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT11_EPDISBLD_OFFSET 0xc68 +#define GC_USB_DOEPINT11_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT11_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT11_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT11_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT11_AHBERR_OFFSET 0xc68 +#define GC_USB_DOEPINT11_SETUP_LSB 0x3 +#define GC_USB_DOEPINT11_SETUP_MASK 0x8 +#define GC_USB_DOEPINT11_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT11_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT11_SETUP_OFFSET 0xc68 +#define GC_USB_DOEPINT11_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT11_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT11_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT11_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT11_OUTTKNEPDIS_OFFSET 0xc68 +#define GC_USB_DOEPINT11_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT11_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT11_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT11_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT11_STSPHSERCVD_OFFSET 0xc68 +#define GC_USB_DOEPINT11_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT11_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT11_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT11_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT11_BACK2BACKSETUP_OFFSET 0xc68 +#define GC_USB_DOEPINT11_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT11_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT11_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT11_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT11_OUTPKTERR_OFFSET 0xc68 +#define GC_USB_DOEPINT11_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT11_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT11_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT11_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT11_BNAINTR_OFFSET 0xc68 +#define GC_USB_DOEPINT11_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT11_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT11_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT11_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT11_PKTDRPSTS_OFFSET 0xc68 +#define GC_USB_DOEPINT11_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT11_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT11_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT11_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT11_BBLEERR_OFFSET 0xc68 +#define GC_USB_DOEPINT11_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT11_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT11_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT11_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT11_NAKINTRPT_OFFSET 0xc68 +#define GC_USB_DOEPINT11_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT11_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT11_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT11_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT11_NYETINTRPT_OFFSET 0xc68 +#define GC_USB_DOEPINT11_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT11_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT11_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT11_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT11_STUPPKTRCVD_OFFSET 0xc68 +#define GC_USB_DOEPTSIZ11_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ11_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ11_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ11_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ11_XFERSIZE_OFFSET 0xc70 +#define GC_USB_DOEPTSIZ11_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ11_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ11_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ11_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ11_PKTCNT_OFFSET 0xc70 +#define GC_USB_DOEPTSIZ11_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ11_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ11_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ11_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ11_RXDPID_OFFSET 0xc70 +#define GC_USB_DOEPDMA11_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA11_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA11_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA11_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA11_DMAADDR_OFFSET 0xc74 +#define GC_USB_DOEPDMAB11_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB11_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB11_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB11_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB11_DMABUFFERADDR_OFFSET 0xc7c +#define GC_USB_DOEPCTL12_MPS_LSB 0x0 +#define GC_USB_DOEPCTL12_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL12_MPS_SIZE 0xb +#define GC_USB_DOEPCTL12_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_MPS_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL12_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL12_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL12_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_USBACTEP_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_DPID_LSB 0x10 +#define GC_USB_DOEPCTL12_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL12_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL12_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_DPID_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL12_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL12_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL12_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_NAKSTS_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL12_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL12_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL12_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_EPTYPE_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_SNP_LSB 0x14 +#define GC_USB_DOEPCTL12_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL12_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL12_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_SNP_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_STALL_LSB 0x15 +#define GC_USB_DOEPCTL12_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL12_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL12_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_STALL_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL12_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL12_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL12_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_CNAK_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL12_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL12_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL12_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_SNAK_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL12_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL12_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL12_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_SETD0PID_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL12_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL12_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL12_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_SETD1PID_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL12_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL12_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL12_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_EPDIS_OFFSET 0xc80 +#define GC_USB_DOEPCTL12_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL12_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL12_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL12_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL12_EPENA_OFFSET 0xc80 +#define GC_USB_DOEPINT12_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT12_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT12_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT12_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT12_XFERCOMPL_OFFSET 0xc88 +#define GC_USB_DOEPINT12_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT12_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT12_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT12_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT12_EPDISBLD_OFFSET 0xc88 +#define GC_USB_DOEPINT12_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT12_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT12_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT12_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT12_AHBERR_OFFSET 0xc88 +#define GC_USB_DOEPINT12_SETUP_LSB 0x3 +#define GC_USB_DOEPINT12_SETUP_MASK 0x8 +#define GC_USB_DOEPINT12_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT12_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT12_SETUP_OFFSET 0xc88 +#define GC_USB_DOEPINT12_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT12_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT12_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT12_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT12_OUTTKNEPDIS_OFFSET 0xc88 +#define GC_USB_DOEPINT12_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT12_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT12_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT12_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT12_STSPHSERCVD_OFFSET 0xc88 +#define GC_USB_DOEPINT12_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT12_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT12_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT12_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT12_BACK2BACKSETUP_OFFSET 0xc88 +#define GC_USB_DOEPINT12_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT12_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT12_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT12_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT12_OUTPKTERR_OFFSET 0xc88 +#define GC_USB_DOEPINT12_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT12_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT12_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT12_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT12_BNAINTR_OFFSET 0xc88 +#define GC_USB_DOEPINT12_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT12_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT12_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT12_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT12_PKTDRPSTS_OFFSET 0xc88 +#define GC_USB_DOEPINT12_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT12_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT12_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT12_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT12_BBLEERR_OFFSET 0xc88 +#define GC_USB_DOEPINT12_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT12_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT12_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT12_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT12_NAKINTRPT_OFFSET 0xc88 +#define GC_USB_DOEPINT12_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT12_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT12_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT12_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT12_NYETINTRPT_OFFSET 0xc88 +#define GC_USB_DOEPINT12_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT12_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT12_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT12_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT12_STUPPKTRCVD_OFFSET 0xc88 +#define GC_USB_DOEPTSIZ12_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ12_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ12_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ12_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ12_XFERSIZE_OFFSET 0xc90 +#define GC_USB_DOEPTSIZ12_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ12_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ12_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ12_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ12_PKTCNT_OFFSET 0xc90 +#define GC_USB_DOEPTSIZ12_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ12_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ12_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ12_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ12_RXDPID_OFFSET 0xc90 +#define GC_USB_DOEPDMA12_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA12_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA12_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA12_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA12_DMAADDR_OFFSET 0xc94 +#define GC_USB_DOEPDMAB12_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB12_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB12_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB12_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB12_DMABUFFERADDR_OFFSET 0xc9c +#define GC_USB_DOEPCTL13_MPS_LSB 0x0 +#define GC_USB_DOEPCTL13_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL13_MPS_SIZE 0xb +#define GC_USB_DOEPCTL13_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_MPS_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL13_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL13_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL13_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_USBACTEP_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_DPID_LSB 0x10 +#define GC_USB_DOEPCTL13_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL13_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL13_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_DPID_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL13_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL13_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL13_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_NAKSTS_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL13_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL13_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL13_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_EPTYPE_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_SNP_LSB 0x14 +#define GC_USB_DOEPCTL13_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL13_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL13_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_SNP_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_STALL_LSB 0x15 +#define GC_USB_DOEPCTL13_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL13_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL13_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_STALL_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL13_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL13_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL13_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_CNAK_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL13_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL13_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL13_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_SNAK_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL13_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL13_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL13_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_SETD0PID_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL13_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL13_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL13_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_SETD1PID_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL13_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL13_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL13_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_EPDIS_OFFSET 0xca0 +#define GC_USB_DOEPCTL13_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL13_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL13_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL13_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL13_EPENA_OFFSET 0xca0 +#define GC_USB_DOEPINT13_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT13_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT13_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT13_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT13_XFERCOMPL_OFFSET 0xca8 +#define GC_USB_DOEPINT13_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT13_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT13_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT13_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT13_EPDISBLD_OFFSET 0xca8 +#define GC_USB_DOEPINT13_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT13_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT13_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT13_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT13_AHBERR_OFFSET 0xca8 +#define GC_USB_DOEPINT13_SETUP_LSB 0x3 +#define GC_USB_DOEPINT13_SETUP_MASK 0x8 +#define GC_USB_DOEPINT13_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT13_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT13_SETUP_OFFSET 0xca8 +#define GC_USB_DOEPINT13_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT13_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT13_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT13_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT13_OUTTKNEPDIS_OFFSET 0xca8 +#define GC_USB_DOEPINT13_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT13_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT13_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT13_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT13_STSPHSERCVD_OFFSET 0xca8 +#define GC_USB_DOEPINT13_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT13_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT13_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT13_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT13_BACK2BACKSETUP_OFFSET 0xca8 +#define GC_USB_DOEPINT13_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT13_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT13_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT13_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT13_OUTPKTERR_OFFSET 0xca8 +#define GC_USB_DOEPINT13_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT13_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT13_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT13_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT13_BNAINTR_OFFSET 0xca8 +#define GC_USB_DOEPINT13_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT13_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT13_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT13_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT13_PKTDRPSTS_OFFSET 0xca8 +#define GC_USB_DOEPINT13_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT13_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT13_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT13_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT13_BBLEERR_OFFSET 0xca8 +#define GC_USB_DOEPINT13_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT13_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT13_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT13_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT13_NAKINTRPT_OFFSET 0xca8 +#define GC_USB_DOEPINT13_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT13_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT13_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT13_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT13_NYETINTRPT_OFFSET 0xca8 +#define GC_USB_DOEPINT13_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT13_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT13_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT13_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT13_STUPPKTRCVD_OFFSET 0xca8 +#define GC_USB_DOEPTSIZ13_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ13_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ13_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ13_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ13_XFERSIZE_OFFSET 0xcb0 +#define GC_USB_DOEPTSIZ13_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ13_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ13_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ13_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ13_PKTCNT_OFFSET 0xcb0 +#define GC_USB_DOEPTSIZ13_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ13_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ13_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ13_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ13_RXDPID_OFFSET 0xcb0 +#define GC_USB_DOEPDMA13_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA13_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA13_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA13_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA13_DMAADDR_OFFSET 0xcb4 +#define GC_USB_DOEPDMAB13_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB13_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB13_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB13_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB13_DMABUFFERADDR_OFFSET 0xcbc +#define GC_USB_DOEPCTL14_MPS_LSB 0x0 +#define GC_USB_DOEPCTL14_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL14_MPS_SIZE 0xb +#define GC_USB_DOEPCTL14_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_MPS_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL14_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL14_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL14_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_USBACTEP_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_DPID_LSB 0x10 +#define GC_USB_DOEPCTL14_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL14_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL14_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_DPID_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL14_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL14_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL14_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_NAKSTS_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL14_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL14_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL14_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_EPTYPE_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_SNP_LSB 0x14 +#define GC_USB_DOEPCTL14_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL14_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL14_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_SNP_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_STALL_LSB 0x15 +#define GC_USB_DOEPCTL14_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL14_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL14_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_STALL_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL14_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL14_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL14_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_CNAK_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL14_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL14_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL14_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_SNAK_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL14_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL14_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL14_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_SETD0PID_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL14_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL14_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL14_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_SETD1PID_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL14_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL14_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL14_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_EPDIS_OFFSET 0xcc0 +#define GC_USB_DOEPCTL14_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL14_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL14_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL14_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL14_EPENA_OFFSET 0xcc0 +#define GC_USB_DOEPINT14_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT14_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT14_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT14_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT14_XFERCOMPL_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT14_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT14_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT14_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT14_EPDISBLD_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT14_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT14_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT14_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT14_AHBERR_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_SETUP_LSB 0x3 +#define GC_USB_DOEPINT14_SETUP_MASK 0x8 +#define GC_USB_DOEPINT14_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT14_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT14_SETUP_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT14_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT14_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT14_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT14_OUTTKNEPDIS_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT14_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT14_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT14_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT14_STSPHSERCVD_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT14_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT14_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT14_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT14_BACK2BACKSETUP_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT14_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT14_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT14_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT14_OUTPKTERR_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT14_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT14_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT14_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT14_BNAINTR_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT14_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT14_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT14_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT14_PKTDRPSTS_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT14_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT14_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT14_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT14_BBLEERR_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT14_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT14_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT14_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT14_NAKINTRPT_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT14_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT14_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT14_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT14_NYETINTRPT_OFFSET 0xcc8 +#define GC_USB_DOEPINT14_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT14_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT14_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT14_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT14_STUPPKTRCVD_OFFSET 0xcc8 +#define GC_USB_DOEPTSIZ14_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ14_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ14_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ14_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ14_XFERSIZE_OFFSET 0xcd0 +#define GC_USB_DOEPTSIZ14_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ14_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ14_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ14_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ14_PKTCNT_OFFSET 0xcd0 +#define GC_USB_DOEPTSIZ14_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ14_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ14_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ14_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ14_RXDPID_OFFSET 0xcd0 +#define GC_USB_DOEPDMA14_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA14_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA14_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA14_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA14_DMAADDR_OFFSET 0xcd4 +#define GC_USB_DOEPDMAB14_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB14_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB14_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB14_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB14_DMABUFFERADDR_OFFSET 0xcdc +#define GC_USB_DOEPCTL15_MPS_LSB 0x0 +#define GC_USB_DOEPCTL15_MPS_MASK 0x7ff +#define GC_USB_DOEPCTL15_MPS_SIZE 0xb +#define GC_USB_DOEPCTL15_MPS_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_MPS_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_USBACTEP_LSB 0xf +#define GC_USB_DOEPCTL15_USBACTEP_MASK 0x8000 +#define GC_USB_DOEPCTL15_USBACTEP_SIZE 0x1 +#define GC_USB_DOEPCTL15_USBACTEP_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_USBACTEP_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_DPID_LSB 0x10 +#define GC_USB_DOEPCTL15_DPID_MASK 0x10000 +#define GC_USB_DOEPCTL15_DPID_SIZE 0x1 +#define GC_USB_DOEPCTL15_DPID_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_DPID_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_NAKSTS_LSB 0x11 +#define GC_USB_DOEPCTL15_NAKSTS_MASK 0x20000 +#define GC_USB_DOEPCTL15_NAKSTS_SIZE 0x1 +#define GC_USB_DOEPCTL15_NAKSTS_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_NAKSTS_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_EPTYPE_LSB 0x12 +#define GC_USB_DOEPCTL15_EPTYPE_MASK 0xc0000 +#define GC_USB_DOEPCTL15_EPTYPE_SIZE 0x2 +#define GC_USB_DOEPCTL15_EPTYPE_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_EPTYPE_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_SNP_LSB 0x14 +#define GC_USB_DOEPCTL15_SNP_MASK 0x100000 +#define GC_USB_DOEPCTL15_SNP_SIZE 0x1 +#define GC_USB_DOEPCTL15_SNP_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_SNP_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_STALL_LSB 0x15 +#define GC_USB_DOEPCTL15_STALL_MASK 0x200000 +#define GC_USB_DOEPCTL15_STALL_SIZE 0x1 +#define GC_USB_DOEPCTL15_STALL_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_STALL_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_CNAK_LSB 0x1a +#define GC_USB_DOEPCTL15_CNAK_MASK 0x4000000 +#define GC_USB_DOEPCTL15_CNAK_SIZE 0x1 +#define GC_USB_DOEPCTL15_CNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_CNAK_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_SNAK_LSB 0x1b +#define GC_USB_DOEPCTL15_SNAK_MASK 0x8000000 +#define GC_USB_DOEPCTL15_SNAK_SIZE 0x1 +#define GC_USB_DOEPCTL15_SNAK_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_SNAK_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_SETD0PID_LSB 0x1c +#define GC_USB_DOEPCTL15_SETD0PID_MASK 0x10000000 +#define GC_USB_DOEPCTL15_SETD0PID_SIZE 0x1 +#define GC_USB_DOEPCTL15_SETD0PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_SETD0PID_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_SETD1PID_LSB 0x1d +#define GC_USB_DOEPCTL15_SETD1PID_MASK 0x20000000 +#define GC_USB_DOEPCTL15_SETD1PID_SIZE 0x1 +#define GC_USB_DOEPCTL15_SETD1PID_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_SETD1PID_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_EPDIS_LSB 0x1e +#define GC_USB_DOEPCTL15_EPDIS_MASK 0x40000000 +#define GC_USB_DOEPCTL15_EPDIS_SIZE 0x1 +#define GC_USB_DOEPCTL15_EPDIS_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_EPDIS_OFFSET 0xce0 +#define GC_USB_DOEPCTL15_EPENA_LSB 0x1f +#define GC_USB_DOEPCTL15_EPENA_MASK 0x80000000 +#define GC_USB_DOEPCTL15_EPENA_SIZE 0x1 +#define GC_USB_DOEPCTL15_EPENA_DEFAULT 0x0 +#define GC_USB_DOEPCTL15_EPENA_OFFSET 0xce0 +#define GC_USB_DOEPINT15_XFERCOMPL_LSB 0x0 +#define GC_USB_DOEPINT15_XFERCOMPL_MASK 0x1 +#define GC_USB_DOEPINT15_XFERCOMPL_SIZE 0x1 +#define GC_USB_DOEPINT15_XFERCOMPL_DEFAULT 0x0 +#define GC_USB_DOEPINT15_XFERCOMPL_OFFSET 0xce8 +#define GC_USB_DOEPINT15_EPDISBLD_LSB 0x1 +#define GC_USB_DOEPINT15_EPDISBLD_MASK 0x2 +#define GC_USB_DOEPINT15_EPDISBLD_SIZE 0x1 +#define GC_USB_DOEPINT15_EPDISBLD_DEFAULT 0x0 +#define GC_USB_DOEPINT15_EPDISBLD_OFFSET 0xce8 +#define GC_USB_DOEPINT15_AHBERR_LSB 0x2 +#define GC_USB_DOEPINT15_AHBERR_MASK 0x4 +#define GC_USB_DOEPINT15_AHBERR_SIZE 0x1 +#define GC_USB_DOEPINT15_AHBERR_DEFAULT 0x0 +#define GC_USB_DOEPINT15_AHBERR_OFFSET 0xce8 +#define GC_USB_DOEPINT15_SETUP_LSB 0x3 +#define GC_USB_DOEPINT15_SETUP_MASK 0x8 +#define GC_USB_DOEPINT15_SETUP_SIZE 0x1 +#define GC_USB_DOEPINT15_SETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT15_SETUP_OFFSET 0xce8 +#define GC_USB_DOEPINT15_OUTTKNEPDIS_LSB 0x4 +#define GC_USB_DOEPINT15_OUTTKNEPDIS_MASK 0x10 +#define GC_USB_DOEPINT15_OUTTKNEPDIS_SIZE 0x1 +#define GC_USB_DOEPINT15_OUTTKNEPDIS_DEFAULT 0x0 +#define GC_USB_DOEPINT15_OUTTKNEPDIS_OFFSET 0xce8 +#define GC_USB_DOEPINT15_STSPHSERCVD_LSB 0x5 +#define GC_USB_DOEPINT15_STSPHSERCVD_MASK 0x20 +#define GC_USB_DOEPINT15_STSPHSERCVD_SIZE 0x1 +#define GC_USB_DOEPINT15_STSPHSERCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT15_STSPHSERCVD_OFFSET 0xce8 +#define GC_USB_DOEPINT15_BACK2BACKSETUP_LSB 0x6 +#define GC_USB_DOEPINT15_BACK2BACKSETUP_MASK 0x40 +#define GC_USB_DOEPINT15_BACK2BACKSETUP_SIZE 0x1 +#define GC_USB_DOEPINT15_BACK2BACKSETUP_DEFAULT 0x0 +#define GC_USB_DOEPINT15_BACK2BACKSETUP_OFFSET 0xce8 +#define GC_USB_DOEPINT15_OUTPKTERR_LSB 0x8 +#define GC_USB_DOEPINT15_OUTPKTERR_MASK 0x100 +#define GC_USB_DOEPINT15_OUTPKTERR_SIZE 0x1 +#define GC_USB_DOEPINT15_OUTPKTERR_DEFAULT 0x0 +#define GC_USB_DOEPINT15_OUTPKTERR_OFFSET 0xce8 +#define GC_USB_DOEPINT15_BNAINTR_LSB 0x9 +#define GC_USB_DOEPINT15_BNAINTR_MASK 0x200 +#define GC_USB_DOEPINT15_BNAINTR_SIZE 0x1 +#define GC_USB_DOEPINT15_BNAINTR_DEFAULT 0x0 +#define GC_USB_DOEPINT15_BNAINTR_OFFSET 0xce8 +#define GC_USB_DOEPINT15_PKTDRPSTS_LSB 0xb +#define GC_USB_DOEPINT15_PKTDRPSTS_MASK 0x800 +#define GC_USB_DOEPINT15_PKTDRPSTS_SIZE 0x1 +#define GC_USB_DOEPINT15_PKTDRPSTS_DEFAULT 0x0 +#define GC_USB_DOEPINT15_PKTDRPSTS_OFFSET 0xce8 +#define GC_USB_DOEPINT15_BBLEERR_LSB 0xc +#define GC_USB_DOEPINT15_BBLEERR_MASK 0x1000 +#define GC_USB_DOEPINT15_BBLEERR_SIZE 0x1 +#define GC_USB_DOEPINT15_BBLEERR_DEFAULT 0x0 +#define GC_USB_DOEPINT15_BBLEERR_OFFSET 0xce8 +#define GC_USB_DOEPINT15_NAKINTRPT_LSB 0xd +#define GC_USB_DOEPINT15_NAKINTRPT_MASK 0x2000 +#define GC_USB_DOEPINT15_NAKINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT15_NAKINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT15_NAKINTRPT_OFFSET 0xce8 +#define GC_USB_DOEPINT15_NYETINTRPT_LSB 0xe +#define GC_USB_DOEPINT15_NYETINTRPT_MASK 0x4000 +#define GC_USB_DOEPINT15_NYETINTRPT_SIZE 0x1 +#define GC_USB_DOEPINT15_NYETINTRPT_DEFAULT 0x0 +#define GC_USB_DOEPINT15_NYETINTRPT_OFFSET 0xce8 +#define GC_USB_DOEPINT15_STUPPKTRCVD_LSB 0xf +#define GC_USB_DOEPINT15_STUPPKTRCVD_MASK 0x8000 +#define GC_USB_DOEPINT15_STUPPKTRCVD_SIZE 0x1 +#define GC_USB_DOEPINT15_STUPPKTRCVD_DEFAULT 0x0 +#define GC_USB_DOEPINT15_STUPPKTRCVD_OFFSET 0xce8 +#define GC_USB_DOEPTSIZ15_XFERSIZE_LSB 0x0 +#define GC_USB_DOEPTSIZ15_XFERSIZE_MASK 0x7ffff +#define GC_USB_DOEPTSIZ15_XFERSIZE_SIZE 0x13 +#define GC_USB_DOEPTSIZ15_XFERSIZE_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ15_XFERSIZE_OFFSET 0xcf0 +#define GC_USB_DOEPTSIZ15_PKTCNT_LSB 0x13 +#define GC_USB_DOEPTSIZ15_PKTCNT_MASK 0x1ff80000 +#define GC_USB_DOEPTSIZ15_PKTCNT_SIZE 0xa +#define GC_USB_DOEPTSIZ15_PKTCNT_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ15_PKTCNT_OFFSET 0xcf0 +#define GC_USB_DOEPTSIZ15_RXDPID_LSB 0x1d +#define GC_USB_DOEPTSIZ15_RXDPID_MASK 0x60000000 +#define GC_USB_DOEPTSIZ15_RXDPID_SIZE 0x2 +#define GC_USB_DOEPTSIZ15_RXDPID_DEFAULT 0x0 +#define GC_USB_DOEPTSIZ15_RXDPID_OFFSET 0xcf0 +#define GC_USB_DOEPDMA15_DMAADDR_LSB 0x0 +#define GC_USB_DOEPDMA15_DMAADDR_MASK 0xffffffff +#define GC_USB_DOEPDMA15_DMAADDR_SIZE 0x20 +#define GC_USB_DOEPDMA15_DMAADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMA15_DMAADDR_OFFSET 0xcf4 +#define GC_USB_DOEPDMAB15_DMABUFFERADDR_LSB 0x0 +#define GC_USB_DOEPDMAB15_DMABUFFERADDR_MASK 0xffffffff +#define GC_USB_DOEPDMAB15_DMABUFFERADDR_SIZE 0x20 +#define GC_USB_DOEPDMAB15_DMABUFFERADDR_DEFAULT 0x0 +#define GC_USB_DOEPDMAB15_DMABUFFERADDR_OFFSET 0xcfc +#define GC_USB_PCGCCTL_STOPPCLK_LSB 0x0 +#define GC_USB_PCGCCTL_STOPPCLK_MASK 0x1 +#define GC_USB_PCGCCTL_STOPPCLK_SIZE 0x1 +#define GC_USB_PCGCCTL_STOPPCLK_DEFAULT 0x0 +#define GC_USB_PCGCCTL_STOPPCLK_OFFSET 0xe00 +#define GC_USB_PCGCCTL_GATEHCLK_LSB 0x1 +#define GC_USB_PCGCCTL_GATEHCLK_MASK 0x2 +#define GC_USB_PCGCCTL_GATEHCLK_SIZE 0x1 +#define GC_USB_PCGCCTL_GATEHCLK_DEFAULT 0x0 +#define GC_USB_PCGCCTL_GATEHCLK_OFFSET 0xe00 +#define GC_USB_PCGCCTL_PWRCLMP_LSB 0x2 +#define GC_USB_PCGCCTL_PWRCLMP_MASK 0x4 +#define GC_USB_PCGCCTL_PWRCLMP_SIZE 0x1 +#define GC_USB_PCGCCTL_PWRCLMP_DEFAULT 0x0 +#define GC_USB_PCGCCTL_PWRCLMP_OFFSET 0xe00 +#define GC_USB_PCGCCTL_RSTPDWNMODULE_LSB 0x3 +#define GC_USB_PCGCCTL_RSTPDWNMODULE_MASK 0x8 +#define GC_USB_PCGCCTL_RSTPDWNMODULE_SIZE 0x1 +#define GC_USB_PCGCCTL_RSTPDWNMODULE_DEFAULT 0x0 +#define GC_USB_PCGCCTL_RSTPDWNMODULE_OFFSET 0xe00 +#define GC_USB_PCGCCTL_PHYSLEEP_LSB 0x6 +#define GC_USB_PCGCCTL_PHYSLEEP_MASK 0x40 +#define GC_USB_PCGCCTL_PHYSLEEP_SIZE 0x1 +#define GC_USB_PCGCCTL_PHYSLEEP_DEFAULT 0x0 +#define GC_USB_PCGCCTL_PHYSLEEP_OFFSET 0xe00 +#define GC_USB_PCGCCTL_L1SUSPENDED_LSB 0x7 +#define GC_USB_PCGCCTL_L1SUSPENDED_MASK 0x80 +#define GC_USB_PCGCCTL_L1SUSPENDED_SIZE 0x1 +#define GC_USB_PCGCCTL_L1SUSPENDED_DEFAULT 0x0 +#define GC_USB_PCGCCTL_L1SUSPENDED_OFFSET 0xe00 +#define GC_USB_DFIFO_SIZE 0x1000 + + +#endif /* __CHIP_STM32_USB_DWC_REGISTERS_H */ diff --git a/chip/stm32/usb_hw.h b/chip/stm32/usb_hw.h index b44a33dcac..29bb347e3c 100644 --- a/chip/stm32/usb_hw.h +++ b/chip/stm32/usb_hw.h @@ -6,6 +6,11 @@ #ifndef __CROS_EC_USB_HW_H #define __CROS_EC_USB_HW_H +#if defined(CHIP_FAMILY_STM32F4) +#include "usb_dwc_hw.h" +#else + + /* * The STM32 has dedicated USB RAM visible on the APB1 bus (so all reads & * writes are 16-bits wide). The endpoint tables and the data buffers live in @@ -82,4 +87,5 @@ extern int (*usb_iface_request[]) (usb_uint *ep0_buf_rx, usb_uint *ep0_buf_tx); usb_uint *epo_buf_tx) \ __attribute__ ((alias(STRINGIFY(handler)))); +#endif #endif /* __CROS_EC_USB_HW_H */ |