diff options
Diffstat (limited to 'tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice')
74 files changed, 31660 insertions, 0 deletions
diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.cpp new file mode 100644 index 000000000..aab9e774e --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.cpp @@ -0,0 +1,618 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBAudio.h" +#include "USBAudio_Types.h" + + + +USBAudio::USBAudio(uint32_t frequency_in, uint8_t channel_nb_in, uint32_t frequency_out, uint8_t channel_nb_out, uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release) { + mute = 0; + volCur = 0x0080; + volMin = 0x0000; + volMax = 0x0100; + volRes = 0x0004; + available = false; + + FREQ_IN = frequency_in; + FREQ_OUT = frequency_out; + + this->channel_nb_in = channel_nb_in; + this->channel_nb_out = channel_nb_out; + + // stereo -> *2, mono -> *1 + PACKET_SIZE_ISO_IN = (FREQ_IN / 500) * channel_nb_in; + PACKET_SIZE_ISO_OUT = (FREQ_OUT / 500) * channel_nb_out; + + // STEREO -> left and right + channel_config_in = (channel_nb_in == 1) ? CHANNEL_M : CHANNEL_L + CHANNEL_R; + channel_config_out = (channel_nb_out == 1) ? CHANNEL_M : CHANNEL_L + CHANNEL_R; + + SOF_handler = false; + + buf_stream_out = NULL; + buf_stream_in = NULL; + + interruptOUT = false; + writeIN = false; + interruptIN = false; + available = false; + + volume = 0; + + // connect the device + USBDevice::connect(); +} + +bool USBAudio::read(uint8_t * buf) { + buf_stream_in = buf; + SOF_handler = false; + while (!available || !SOF_handler); + available = false; + return true; +} + +bool USBAudio::readNB(uint8_t * buf) { + buf_stream_in = buf; + SOF_handler = false; + while (!SOF_handler); + if (available) { + available = false; + buf_stream_in = NULL; + return true; + } + return false; +} + +bool USBAudio::readWrite(uint8_t * buf_read, uint8_t * buf_write) { + buf_stream_in = buf_read; + SOF_handler = false; + writeIN = false; + if (interruptIN) { + USBDevice::writeNB(EP3IN, buf_write, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT); + } else { + buf_stream_out = buf_write; + } + while (!available); + if (interruptIN) { + while (!writeIN); + } + while (!SOF_handler); + return true; +} + + +bool USBAudio::write(uint8_t * buf) { + writeIN = false; + SOF_handler = false; + if (interruptIN) { + USBDevice::writeNB(EP3IN, buf, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT); + } else { + buf_stream_out = buf; + } + while (!SOF_handler); + if (interruptIN) { + while (!writeIN); + } + return true; +} + + +float USBAudio::getVolume() { + return (mute) ? 0.0 : volume; +} + + +bool USBAudio::EPISO_OUT_callback() { + uint32_t size = 0; + interruptOUT = true; + if (buf_stream_in != NULL) { + readEP(EP3OUT, (uint8_t *)buf_stream_in, &size, PACKET_SIZE_ISO_IN); + available = true; + buf_stream_in = NULL; + } + readStart(EP3OUT, PACKET_SIZE_ISO_IN); + return false; +} + + +bool USBAudio::EPISO_IN_callback() { + interruptIN = true; + writeIN = true; + return true; +} + + + +// Called in ISR context on each start of frame +void USBAudio::SOF(int frameNumber) { + uint32_t size = 0; + + if (!interruptOUT) { + // read the isochronous endpoint + if (buf_stream_in != NULL) { + if (USBDevice::readEP_NB(EP3OUT, (uint8_t *)buf_stream_in, &size, PACKET_SIZE_ISO_IN)) { + if (size) { + available = true; + readStart(EP3OUT, PACKET_SIZE_ISO_IN); + buf_stream_in = NULL; + } + } + } + } + + if (!interruptIN) { + // write if needed + if (buf_stream_out != NULL) { + USBDevice::writeNB(EP3IN, (uint8_t *)buf_stream_out, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT); + buf_stream_out = NULL; + } + } + + SOF_handler = true; +} + + +// Called in ISR context +// Set configuration. Return false if the configuration is not supported. +bool USBAudio::USBCallback_setConfiguration(uint8_t configuration) { + if (configuration != DEFAULT_CONFIGURATION) { + return false; + } + + // Configure isochronous endpoint + realiseEndpoint(EP3OUT, PACKET_SIZE_ISO_IN, ISOCHRONOUS); + realiseEndpoint(EP3IN, PACKET_SIZE_ISO_OUT, ISOCHRONOUS); + + // activate readings on this endpoint + readStart(EP3OUT, PACKET_SIZE_ISO_IN); + return true; +} + + +// Called in ISR context +// Set alternate setting. Return false if the alternate setting is not supported +bool USBAudio::USBCallback_setInterface(uint16_t interface, uint8_t alternate) { + if (interface == 0 && alternate == 0) { + return true; + } + if (interface == 1 && (alternate == 0 || alternate == 1)) { + return true; + } + if (interface == 2 && (alternate == 0 || alternate == 1)) { + return true; + } + return false; +} + + + +// Called in ISR context +// Called by USBDevice on Endpoint0 request +// This is used to handle extensions to standard requests and class specific requests. +// Return true if class handles this request +bool USBAudio::USBCallback_request() { + bool success = false; + CONTROL_TRANSFER * transfer = getTransferPtr(); + + // Process class-specific requests + if (transfer->setup.bmRequestType.Type == CLASS_TYPE) { + + // Feature Unit: Interface = 0, ID = 2 + if (transfer->setup.wIndex == 0x0200) { + + // Master Channel + if ((transfer->setup.wValue & 0xff) == 0) { + + switch (transfer->setup.wValue >> 8) { + case MUTE_CONTROL: + switch (transfer->setup.bRequest) { + case REQUEST_GET_CUR: + transfer->remaining = 1; + transfer->ptr = &mute; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + + case REQUEST_SET_CUR: + transfer->remaining = 1; + transfer->notify = true; + transfer->direction = HOST_TO_DEVICE; + success = true; + break; + default: + break; + } + break; + case VOLUME_CONTROL: + switch (transfer->setup.bRequest) { + case REQUEST_GET_CUR: + transfer->remaining = 2; + transfer->ptr = (uint8_t *)&volCur; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + case REQUEST_GET_MIN: + transfer->remaining = 2; + transfer->ptr = (uint8_t *)&volMin; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + case REQUEST_GET_MAX: + transfer->remaining = 2; + transfer->ptr = (uint8_t *)&volMax; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + case REQUEST_GET_RES: + transfer->remaining = 2; + transfer->ptr = (uint8_t *)&volRes; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + + case REQUEST_SET_CUR: + transfer->remaining = 2; + transfer->notify = true; + transfer->direction = HOST_TO_DEVICE; + success = true; + break; + case REQUEST_SET_MIN: + transfer->remaining = 2; + transfer->notify = true; + transfer->direction = HOST_TO_DEVICE; + success = true; + break; + case REQUEST_SET_MAX: + transfer->remaining = 2; + transfer->notify = true; + transfer->direction = HOST_TO_DEVICE; + success = true; + break; + case REQUEST_SET_RES: + transfer->remaining = 2; + transfer->notify = true; + transfer->direction = HOST_TO_DEVICE; + success = true; + break; + } + break; + default: + break; + } + } + } + } + return success; +} + + +// Called in ISR context when a data OUT stage has been performed +void USBAudio::USBCallback_requestCompleted(uint8_t * buf, uint32_t length) { + if ((length == 1) || (length == 2)) { + uint16_t data = (length == 1) ? *buf : *((uint16_t *)buf); + CONTROL_TRANSFER * transfer = getTransferPtr(); + switch (transfer->setup.wValue >> 8) { + case MUTE_CONTROL: + switch (transfer->setup.bRequest) { + case REQUEST_SET_CUR: + mute = data & 0xff; + updateVol.call(); + break; + default: + break; + } + break; + case VOLUME_CONTROL: + switch (transfer->setup.bRequest) { + case REQUEST_SET_CUR: + volCur = data; + volume = (float)volCur/(float)volMax; + updateVol.call(); + break; + default: + break; + } + break; + default: + break; + } + } +} + + + +#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \ + + (5 * INTERFACE_DESCRIPTOR_LENGTH) \ + + (1 * CONTROL_INTERFACE_DESCRIPTOR_LENGTH + 1) \ + + (2 * INPUT_TERMINAL_DESCRIPTOR_LENGTH) \ + + (1 * FEATURE_UNIT_DESCRIPTOR_LENGTH) \ + + (2 * OUTPUT_TERMINAL_DESCRIPTOR_LENGTH) \ + + (2 * STREAMING_INTERFACE_DESCRIPTOR_LENGTH) \ + + (2 * FORMAT_TYPE_I_DESCRIPTOR_LENGTH) \ + + (2 * (ENDPOINT_DESCRIPTOR_LENGTH + 2)) \ + + (2 * STREAMING_ENDPOINT_DESCRIPTOR_LENGTH) ) + +#define TOTAL_CONTROL_INTF_LENGTH (CONTROL_INTERFACE_DESCRIPTOR_LENGTH + 1 + \ + 2*INPUT_TERMINAL_DESCRIPTOR_LENGTH + \ + FEATURE_UNIT_DESCRIPTOR_LENGTH + \ + 2*OUTPUT_TERMINAL_DESCRIPTOR_LENGTH) + +uint8_t * USBAudio::configurationDesc() { + static uint8_t configDescriptor[] = { + // Configuration 1 + CONFIGURATION_DESCRIPTOR_LENGTH, // bLength + CONFIGURATION_DESCRIPTOR, // bDescriptorType + LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB) + MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB) + 0x03, // bNumInterfaces + DEFAULT_CONFIGURATION, // bConfigurationValue + 0x00, // iConfiguration + 0x80, // bmAttributes + 50, // bMaxPower + + // Interface 0, Alternate Setting 0, Audio Control + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x00, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x00, // bNumEndpoints + AUDIO_CLASS, // bInterfaceClass + SUBCLASS_AUDIOCONTROL, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0x00, // iInterface + + + // Audio Control Interface + CONTROL_INTERFACE_DESCRIPTOR_LENGTH + 1,// bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + CONTROL_HEADER, // bDescriptorSubtype + LSB(0x0100), // bcdADC (LSB) + MSB(0x0100), // bcdADC (MSB) + LSB(TOTAL_CONTROL_INTF_LENGTH), // wTotalLength + MSB(TOTAL_CONTROL_INTF_LENGTH), // wTotalLength + 0x02, // bInCollection + 0x01, // baInterfaceNr + 0x02, // baInterfaceNr + + // Audio Input Terminal (Speaker) + INPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + CONTROL_INPUT_TERMINAL, // bDescriptorSubtype + 0x01, // bTerminalID + LSB(TERMINAL_USB_STREAMING), // wTerminalType + MSB(TERMINAL_USB_STREAMING), // wTerminalType + 0x00, // bAssocTerminal + channel_nb_in, // bNrChannels + (uint8_t)(LSB(channel_config_in)), // wChannelConfig + (uint8_t)(MSB(channel_config_in)), // wChannelConfig + 0x00, // iChannelNames + 0x00, // iTerminal + + // Audio Feature Unit (Speaker) + FEATURE_UNIT_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + CONTROL_FEATURE_UNIT, // bDescriptorSubtype + 0x02, // bUnitID + 0x01, // bSourceID + 0x01, // bControlSize + CONTROL_MUTE | + CONTROL_VOLUME, // bmaControls(0) + 0x00, // bmaControls(1) + 0x00, // iTerminal + + // Audio Output Terminal (Speaker) + OUTPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + CONTROL_OUTPUT_TERMINAL, // bDescriptorSubtype + 0x03, // bTerminalID + LSB(TERMINAL_SPEAKER), // wTerminalType + MSB(TERMINAL_SPEAKER), // wTerminalType + 0x00, // bAssocTerminal + 0x02, // bSourceID + 0x00, // iTerminal + + + // Audio Input Terminal (Microphone) + INPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + CONTROL_INPUT_TERMINAL, // bDescriptorSubtype + 0x04, // bTerminalID + LSB(TERMINAL_MICROPHONE), // wTerminalType + MSB(TERMINAL_MICROPHONE), // wTerminalType + 0x00, // bAssocTerminal + channel_nb_out, // bNrChannels + (uint8_t)(LSB(channel_config_out)), // wChannelConfig + (uint8_t)(MSB(channel_config_out)), // wChannelConfig + 0x00, // iChannelNames + 0x00, // iTerminal + + // Audio Output Terminal (Microphone) + OUTPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + CONTROL_OUTPUT_TERMINAL, // bDescriptorSubtype + 0x05, // bTerminalID + LSB(TERMINAL_USB_STREAMING), // wTerminalType + MSB(TERMINAL_USB_STREAMING), // wTerminalType + 0x00, // bAssocTerminal + 0x04, // bSourceID + 0x00, // iTerminal + + + + + + + // Interface 1, Alternate Setting 0, Audio Streaming - Zero Bandwith + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x01, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x00, // bNumEndpoints + AUDIO_CLASS, // bInterfaceClass + SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0x00, // iInterface + + // Interface 1, Alternate Setting 1, Audio Streaming - Operational + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x01, // bInterfaceNumber + 0x01, // bAlternateSetting + 0x01, // bNumEndpoints + AUDIO_CLASS, // bInterfaceClass + SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0x00, // iInterface + + // Audio Streaming Interface + STREAMING_INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + STREAMING_GENERAL, // bDescriptorSubtype + 0x01, // bTerminalLink + 0x00, // bDelay + LSB(FORMAT_PCM), // wFormatTag + MSB(FORMAT_PCM), // wFormatTag + + // Audio Type I Format + FORMAT_TYPE_I_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + STREAMING_FORMAT_TYPE, // bDescriptorSubtype + FORMAT_TYPE_I, // bFormatType + channel_nb_in, // bNrChannels + 0x02, // bSubFrameSize + 16, // bBitResolution + 0x01, // bSamFreqType + (uint8_t)(LSB(FREQ_IN)), // tSamFreq + (uint8_t)((FREQ_IN >> 8) & 0xff), // tSamFreq + (uint8_t)((FREQ_IN >> 16) & 0xff), // tSamFreq + + // Endpoint - Standard Descriptor + ENDPOINT_DESCRIPTOR_LENGTH + 2, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPISO_OUT), // bEndpointAddress + E_ISOCHRONOUS, // bmAttributes + (uint8_t)(LSB(PACKET_SIZE_ISO_IN)), // wMaxPacketSize + (uint8_t)(MSB(PACKET_SIZE_ISO_IN)), // wMaxPacketSize + 0x01, // bInterval + 0x00, // bRefresh + 0x00, // bSynchAddress + + // Endpoint - Audio Streaming + STREAMING_ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR_TYPE, // bDescriptorType + ENDPOINT_GENERAL, // bDescriptor + 0x00, // bmAttributes + 0x00, // bLockDelayUnits + LSB(0x0000), // wLockDelay + MSB(0x0000), // wLockDelay + + + + + + + + // Interface 1, Alternate Setting 0, Audio Streaming - Zero Bandwith + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x02, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x00, // bNumEndpoints + AUDIO_CLASS, // bInterfaceClass + SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0x00, // iInterface + + // Interface 1, Alternate Setting 1, Audio Streaming - Operational + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x02, // bInterfaceNumber + 0x01, // bAlternateSetting + 0x01, // bNumEndpoints + AUDIO_CLASS, // bInterfaceClass + SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0x00, // iInterface + + // Audio Streaming Interface + STREAMING_INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + SUBCLASS_AUDIOCONTROL, // bDescriptorSubtype + 0x05, // bTerminalLink (output terminal microphone) + 0x01, // bDelay + 0x01, // wFormatTag + 0x00, // wFormatTag + + // Audio Type I Format + FORMAT_TYPE_I_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType + SUBCLASS_AUDIOSTREAMING, // bDescriptorSubtype + FORMAT_TYPE_I, // bFormatType + channel_nb_out, // bNrChannels + 0x02, // bSubFrameSize + 0x10, // bBitResolution + 0x01, // bSamFreqType + (uint8_t)(LSB(FREQ_OUT)), // tSamFreq + (uint8_t)((FREQ_OUT >> 8) & 0xff), // tSamFreq + (uint8_t)((FREQ_OUT >> 16) & 0xff), // tSamFreq + + // Endpoint - Standard Descriptor + ENDPOINT_DESCRIPTOR_LENGTH + 2, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPISO_IN), // bEndpointAddress + E_ISOCHRONOUS, // bmAttributes + (uint8_t)(LSB(PACKET_SIZE_ISO_OUT)), // wMaxPacketSize + (uint8_t)(MSB(PACKET_SIZE_ISO_OUT)), // wMaxPacketSize + 0x01, // bInterval + 0x00, // bRefresh + 0x00, // bSynchAddress + + // Endpoint - Audio Streaming + STREAMING_ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR_TYPE, // bDescriptorType + ENDPOINT_GENERAL, // bDescriptor + 0x00, // bmAttributes + 0x00, // bLockDelayUnits + LSB(0x0000), // wLockDelay + MSB(0x0000), // wLockDelay + + // Terminator + 0 // bLength + }; + return configDescriptor; +} + +uint8_t * USBAudio::stringIinterfaceDesc() { + static uint8_t stringIinterfaceDescriptor[] = { + 0x0c, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'A',0,'u',0,'d',0,'i',0,'o',0 //bString iInterface - Audio + }; + return stringIinterfaceDescriptor; +} + +uint8_t * USBAudio::stringIproductDesc() { + static uint8_t stringIproductDescriptor[] = { + 0x16, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'M',0,'b',0,'e',0,'d',0,' ',0,'A',0,'u',0,'d',0,'i',0,'o',0 //bString iProduct - Mbed Audio + }; + return stringIproductDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.h new file mode 100644 index 000000000..5038f053c --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.h @@ -0,0 +1,287 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBAudio_H +#define USBAudio_H + +/* These headers are included for child class. */ +#include "USBEndpoints.h" +#include "USBDescriptor.h" +#include "USBDevice_Types.h" + +#include "USBDevice.h" + + +/** +* USBAudio example +* +* @code +* #include "mbed.h" +* #include "USBAudio.h" +* +* Serial pc(USBTX, USBRX); +* +* // frequency: 48 kHz +* #define FREQ 48000 +* +* // 1 channel: mono +* #define NB_CHA 1 +* +* // length of an audio packet: each ms, we receive 48 * 16bits ->48 * 2 bytes. as there is one channel, the length will be 48 * 2 * 1 +* #define AUDIO_LENGTH_PACKET 48 * 2 * 1 +* +* // USBAudio +* USBAudio audio(FREQ, NB_CHA); +* +* int main() { +* int16_t buf[AUDIO_LENGTH_PACKET/2]; +* +* while (1) { +* // read an audio packet +* audio.read((uint8_t *)buf); +* +* +* // print packet received +* pc.printf("recv: "); +* for(int i = 0; i < AUDIO_LENGTH_PACKET/2; i++) { +* pc.printf("%d ", buf[i]); +* } +* pc.printf("\r\n"); +* } +* } +* @endcode +*/ +class USBAudio: public USBDevice { +public: + + /** + * Constructor + * + * @param frequency_in frequency in Hz (default: 48000) + * @param channel_nb_in channel number (1 or 2) (default: 1) + * @param frequency_out frequency in Hz (default: 8000) + * @param channel_nb_out_in channel number (1 or 2) (default: 1) + * @param vendor_id Your vendor_id + * @param product_id Your product_id + * @param product_release Your preoduct_release + */ + USBAudio(uint32_t frequency_in = 48000, uint8_t channel_nb_in = 1, uint32_t frequency_out = 8000, uint8_t channel_nb_out = 1, uint16_t vendor_id = 0x7bb8, uint16_t product_id = 0x1111, uint16_t product_release = 0x0100); + + /** + * Get current volume between 0.0 and 1.0 + * + * @returns volume + */ + float getVolume(); + + /** + * Read an audio packet. During a frame, only a single reading (you can't write and read an audio packet during the same frame)can be done using this method. Warning: Blocking + * + * @param buf pointer on a buffer which will be filled with an audio packet + * + * @returns true if successfull + */ + bool read(uint8_t * buf); + + /** + * Try to read an audio packet. During a frame, only a single reading (you can't write and read an audio packet during the same frame)can be done using this method. Warning: Non Blocking + * + * @param buf pointer on a buffer which will be filled if an audio packet is available + * + * @returns true if successfull + */ + bool readNB(uint8_t * buf); + + /** + * Write an audio packet. During a frame, only a single writing (you can't write and read an audio packet during the same frame)can be done using this method. + * + * @param buf pointer on the audio packet which will be sent + * @returns true if successful + */ + bool write(uint8_t * buf); + + /** + * Write and read an audio packet at the same time (on the same frame) + * + * @param buf_read pointer on a buffer which will be filled with an audio packet + * @param buf_write pointer on the audio packet which will be sent + * @returns true if successful + */ + bool readWrite(uint8_t * buf_read, uint8_t * buf_write); + + + /** attach a handler to update the volume + * + * @param function Function to attach + * + */ + void attach(void(*fptr)(void)) { + updateVol.attach(fptr); + } + + /** Attach a nonstatic void/void member function to update the volume + * + * @param tptr Object pointer + * @param mptr Member function pointer + * + */ + template<typename T> + void attach(T *tptr, void(T::*mptr)(void)) { + updateVol.attach(tptr, mptr); + } + + +protected: + + /* + * Called by USBDevice layer. Set configuration of the device. + * For instance, you can add all endpoints that you need on this function. + * + * @param configuration Number of the configuration + * @returns true if class handles this request + */ + virtual bool USBCallback_setConfiguration(uint8_t configuration); + + /* + * Called by USBDevice on Endpoint0 request. Warning: Called in ISR context + * This is used to handle extensions to standard requests + * and class specific requests + * + * @returns true if class handles this request + */ + virtual bool USBCallback_request(); + + /* + * Get string product descriptor + * + * @returns pointer to the string product descriptor + */ + virtual uint8_t * stringIproductDesc(); + + /* + * Get string interface descriptor + * + * @returns pointer to the string interface descriptor + */ + virtual uint8_t * stringIinterfaceDesc(); + + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + + /* + * Called by USBDevice layer. Set interface/alternate of the device. + * + * @param interface Number of the interface to be configured + * @param alternate Number of the alternate to be configured + * @returns true if class handles this request + */ + virtual bool USBCallback_setInterface(uint16_t interface, uint8_t alternate); + + /* + * Called by USBDevice on Endpoint0 request completion + * if the 'notify' flag has been set to true. Warning: Called in ISR context + * + * In this case it is used to indicate that a HID report has + * been received from the host on endpoint 0 + * + * @param buf buffer received on endpoint 0 + * @param length length of this buffer + */ + virtual void USBCallback_requestCompleted(uint8_t * buf, uint32_t length); + + /* + * Callback called on each Start of Frame event + */ + virtual void SOF(int frameNumber); + + /* + * Callback called when a packet is received + */ + virtual bool EPISO_OUT_callback(); + + /* + * Callback called when a packet has been sent + */ + virtual bool EPISO_IN_callback(); + +private: + + // stream available ? + volatile bool available; + + // interrupt OUT has been received + volatile bool interruptOUT; + + // interrupt IN has been received + volatile bool interruptIN; + + // audio packet has been written + volatile bool writeIN; + + // FREQ + uint32_t FREQ_OUT; + uint32_t FREQ_IN; + + // size of the maximum packet for the isochronous endpoint + uint32_t PACKET_SIZE_ISO_IN; + uint32_t PACKET_SIZE_ISO_OUT; + + // mono, stereo,... + uint8_t channel_nb_in; + uint8_t channel_nb_out; + + // channel config: master, left, right + uint8_t channel_config_in; + uint8_t channel_config_out; + + // mute state + uint8_t mute; + + // Volume Current Value + uint16_t volCur; + + // Volume Minimum Value + uint16_t volMin; + + // Volume Maximum Value + uint16_t volMax; + + // Volume Resolution + uint16_t volRes; + + // Buffer containing one audio packet (to be read) + volatile uint8_t * buf_stream_in; + + // Buffer containing one audio packet (to be written) + volatile uint8_t * buf_stream_out; + + // callback to update volume + FunctionPointer updateVol; + + // boolean showing that the SOF handler has been called. Useful for readNB. + volatile bool SOF_handler; + + volatile float volume; + +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio_Types.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio_Types.h new file mode 100644 index 000000000..1151a7200 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio_Types.h @@ -0,0 +1,97 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBAUDIO_TYPES_H +#define USBAUDIO_TYPES_H + + +#define DEFAULT_CONFIGURATION (1) + +// Audio Request Codes +#define REQUEST_SET_CUR 0x01 +#define REQUEST_GET_CUR 0x81 +#define REQUEST_SET_MIN 0x02 +#define REQUEST_GET_MIN 0x82 +#define REQUEST_SET_MAX 0x03 +#define REQUEST_GET_MAX 0x83 +#define REQUEST_SET_RES 0x04 +#define REQUEST_GET_RES 0x84 + +#define MUTE_CONTROL 0x01 +#define VOLUME_CONTROL 0x02 + + +// Audio Descriptor Sizes +#define CONTROL_INTERFACE_DESCRIPTOR_LENGTH 0x09 +#define STREAMING_INTERFACE_DESCRIPTOR_LENGTH 0x07 +#define INPUT_TERMINAL_DESCRIPTOR_LENGTH 0x0C +#define OUTPUT_TERMINAL_DESCRIPTOR_LENGTH 0x09 +#define FEATURE_UNIT_DESCRIPTOR_LENGTH 0x09 +#define STREAMING_ENDPOINT_DESCRIPTOR_LENGTH 0x07 + +// Audio Format Type Descriptor Sizes +#define FORMAT_TYPE_I_DESCRIPTOR_LENGTH 0x0b + +#define AUDIO_CLASS 0x01 +#define SUBCLASS_AUDIOCONTROL 0x01 +#define SUBCLASS_AUDIOSTREAMING 0x02 + +// Audio Descriptor Types +#define INTERFACE_DESCRIPTOR_TYPE 0x24 +#define ENDPOINT_DESCRIPTOR_TYPE 0x25 + +// Audio Control Interface Descriptor Subtypes +#define CONTROL_HEADER 0x01 +#define CONTROL_INPUT_TERMINAL 0x02 +#define CONTROL_OUTPUT_TERMINAL 0x03 +#define CONTROL_FEATURE_UNIT 0x06 + +// USB Terminal Types +#define TERMINAL_USB_STREAMING 0x0101 + +// Predefined Audio Channel Configuration Bits +// Mono +#define CHANNEL_M 0x0000 +#define CHANNEL_L 0x0001 /* Left Front */ +#define CHANNEL_R 0x0002 /* Right Front */ + +// Feature Unit Control Bits +#define CONTROL_MUTE 0x0001 +#define CONTROL_VOLUME 0x0002 + +// Input Terminal Types +#define TERMINAL_MICROPHONE 0x0201 + +// Output Terminal Types +#define TERMINAL_SPEAKER 0x0301 +#define TERMINAL_HEADPHONES 0x0302 + +// Audio Streaming Interface Descriptor Subtypes +#define STREAMING_GENERAL 0x01 +#define STREAMING_FORMAT_TYPE 0x02 + +// Audio Data Format Type I Codes +#define FORMAT_PCM 0x0001 + +// Audio Format Types +#define FORMAT_TYPE_I 0x01 + +// Audio Endpoint Descriptor Subtypes +#define ENDPOINT_GENERAL 0x01 + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h new file mode 100644 index 000000000..d319e60f3 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h @@ -0,0 +1,365 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : devdrv_usb_function_api.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB_FUNCTION_API_H +#define USB_FUNCTION_API_H + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include <MBRZA1H.h> +#include "r_typedefs.h" +#include "usb0_function_api.h" +#include "usb1_function_api.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ +typedef struct +{ + uint32_t fifo; + uint32_t buffer; + uint32_t bytes; + uint32_t dir; + uint32_t size; +} USB_FUNCTION_DMA_t; + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +#define USBFCLOCK_X1_48MHZ (0x0000u) /* USB_X1_48MHz */ +#define USBFCLOCK_EXTAL_12MHZ (0x0004u) /* EXTAL_12MHz */ + +#define DEVDRV_USBF_ON (1) +#define DEVDRV_USBF_OFF (0) +#define DEVDRV_USBF_YES (1) +#define DEVDRV_USBF_NO (0) + +#define DEVDRV_USBF_STALL (-2) + +#define DEVDRV_USBF_WRITEEND (0) +#define DEVDRV_USBF_WRITESHRT (1) +#define DEVDRV_USBF_WRITING (2) +#define DEVDRV_USBF_WRITEDMA (3) + +#define DEVDRV_USBF_FIFOERROR (0xffff) + +#define DEVDRV_USBF_PIPE_IDLE (0x00) +#define DEVDRV_USBF_PIPE_WAIT (0x01) +#define DEVDRV_USBF_PIPE_DONE (0x02) +#define DEVDRV_USBF_PIPE_NORES (0x03) +#define DEVDRV_USBF_PIPE_STALL (0x04) + +#define DEVDRV_USBF_PID_NAK (0x0000u) +#define DEVDRV_USBF_PID_BUF (0x0001u) +#define DEVDRV_USBF_PID_STALL (0x0002u) +#define DEVDRV_USBF_PID_STALL2 (0x0003u) + +#define USB_FUNCTION_NON_SPEED (0) +#define USB_FUNCTION_LOW_SPEED (1) +#define USB_FUNCTION_FULL_SPEED (2) +#define USB_FUNCTION_HIGH_SPEED (3) + +#define USB_FUNCTION_READEND (0) +#define USB_FUNCTION_READSHRT (1) +#define USB_FUNCTION_READING (2) +#define USB_FUNCTION_READOVER (3) +#define USB_FUNCTION_READZERO (4) + +#define USB_FUNCTION_MAX_PIPE_NO (15u) +#define USB_FUNCTION_PIPE0 (0) +#define USB_FUNCTION_PIPE1 (1) +#define USB_FUNCTION_PIPE2 (2) +#define USB_FUNCTION_PIPE3 (3) +#define USB_FUNCTION_PIPE4 (4) +#define USB_FUNCTION_PIPE5 (5) +#define USB_FUNCTION_PIPE6 (6) +#define USB_FUNCTION_PIPE7 (7) +#define USB_FUNCTION_PIPE8 (8) +#define USB_FUNCTION_PIPE9 (9) +#define USB_FUNCTION_PIPEA (10) +#define USB_FUNCTION_PIPEB (11) +#define USB_FUNCTION_PIPEC (12) +#define USB_FUNCTION_PIPED (13) +#define USB_FUNCTION_PIPEE (14) +#define USB_FUNCTION_PIPEF (15) + +#define USB_FUNCTION_ISO (0xc000u) +#define USB_FUNCTION_INTERRUPT (0x8000u) +#define USB_FUNCTION_BULK (0x4000u) + +#define USB_FUNCTION_NONE (0x0000u) +#define USB_FUNCTON_BFREFIELD (0x0400u) +#define USB_FUNCTION_BFREON (0x0400u) +#define USB_FUNCTION_BFREOFF (0x0000u) +#define USB_FUNCTION_DBLBFIELD (0x0200u) +#define USB_FUNCTION_DBLBON (0x0200u) +#define USB_FUNCTION_DBLBOFF (0x0000u) +#define USB_FUNCTION_CNTMDFIELD (0x0100u) +#define USB_FUNCTION_CNTMDON (0x0100u) +#define USB_FUNCTION_CNTMDOFF (0x0000u) +#define USB_FUNCTION_SHTNAKON (0x0080u) +#define USB_FUNCTION_SHTNAKOFF (0x0000u) +#define USB_FUNCTION_DIRFIELD (0x0010u) +#define USB_FUNCTION_DIR_P_OUT (0x0000u) +#define USB_FUNCTION_DIR_P_IN (0x0010u) +#define USB_FUNCTION_EPNUMFIELD (0x000fu) +#define USB_FUNCTION_MAX_EP_NO (15u) +#define USB_FUNCTION_EP0 (0u) +#define USB_FUNCTION_EP1 (1u) +#define USB_FUNCTION_EP2 (2u) +#define USB_FUNCTION_EP3 (3u) +#define USB_FUNCTION_EP4 (4u) +#define USB_FUNCTION_EP5 (5u) +#define USB_FUNCTION_EP6 (6u) +#define USB_FUNCTION_EP7 (7u) +#define USB_FUNCTION_EP8 (8u) +#define USB_FUNCTION_EP9 (9u) +#define USB_FUNCTION_EP10 (10u) +#define USB_FUNCTION_EP11 (11u) +#define USB_FUNCTION_EP12 (12u) +#define USB_FUNCTION_EP13 (13u) +#define USB_FUNCTION_EP14 (14u) +#define USB_FUNCTION_EP15 (15u) + +#define USB_FUNCTION_EPTABLE_LENGTH (5u) + +#define USB_FUNCTION_CUSE (0) +#define USB_FUNCTION_D0USE (1) +#define USB_FUNCTION_D0DMA (2) +#define USB_FUNCTION_D1USE (3) +#define USB_FUNCTION_D1DMA (4) + +#define USB_FUNCTION_CFIFO_USE (0x0000) +#define USB_FUNCTION_D0FIFO_USE (0x1000) +#define USB_FUNCTION_D1FIFO_USE (0x2000) +#define USB_FUNCTION_D0FIFO_DMA (0x5000) +#define USB_FUNCTION_D1FIFO_DMA (0x6000) + +#define USB_FUNCTION_BUF2FIFO (0) +#define USB_FUNCTION_FIFO2BUF (1) + +#define USB_FUNCTION_DVST_POWERED (0x0001) +#define USB_FUNCTION_DVST_DEFAULT (0x0002) +#define USB_FUNCTION_DVST_ADDRESS (0x0003) +#define USB_FUNCTION_DVST_CONFIGURED (0x0004) +#define USB_FUNCTION_DVST_SUSPEND (0x0005) +#define USB_FUNCTION_DVST_CONFIGURED_SUSPEND (0x0006) + +#define USB_FUNCTION_FUNCTION_TEST_SELECT (0xff00u) +#define USB_FUNCTION_FUNCTION_TEST_J (0x0100u) +#define USB_FUNCTION_FUNCTION_TEST_K (0x0200u) +#define USB_FUNCTION_FUNCTION_TEST_SE0_NAK (0x0300u) +#define USB_FUNCTION_FUNCTION_TEST_PACKET (0x0400u) +#define USB_FUNCTION_FUNCTION_TEST_FORCE_ENABLE (0x0500u) +#define USB_FUNCTION_FUNCTION_TEST_STSelectors (0x0600u) +#define USB_FUNCTION_FUNCTION_TEST_Reserved (0x4000u) +#define USB_FUNCTION_FUNCTION_TEST_VSTModes (0xc000u) + +#define USB_FUNCTION_DT_TYPE (0xff00u) +#define USB_FUNCTION_DT_INDEX (0xff) +#define USB_FUNCTION_DT_DEVICE (0x01) +#define USB_FUNCTION_DT_CONFIGURATION (0x02) +#define USB_FUNCTION_DT_STRING (0x03) +#define USB_FUNCTION_DT_INTERFACE (0x04) +#define USB_FUNCTION_DT_ENDPOINT (0x05) +#define USB_FUNCTION_DT_DEVICE_QUALIFIER (0x06) +#define USB_FUNCTION_DT_OTHER_SPEED_CONFIGURATION (0x07) +#define USB_FUNCTION_DT_INTERFACE_POWER (0x08) + +#define USB_FUNCTION_CF_RESERVED (0x80) +#define USB_FUNCTION_CF_SELF (0x40) +#define USB_FUNCTION_CF_RWUP (0x20) +#define USB_FUNCTION_CF_NORWUP (0x00) +#define USB_FUNCTION_EP_ERROR (0xff) + +#define USB_FUNCTION_EP_OUT (0x00) +#define USB_FUNCTION_EP_IN (0x80) +#define USB_FUNCTION_EP_CNTRL (0x00) +#define USB_FUNCTION_EP_ISO (0x01) +#define USB_FUNCTION_EP_BULK (0x02) +#define USB_FUNCTION_EP_INT (0x03) + +#define USB_FUNCTION_STANDARD_REQUEST (0x0000u) +#define USB_FUNCTION_CLASS_REQUEST (0x0020u) +#define USB_FUNCTION_VENDOR_REQUEST (0x0040u) +#define USB_FUNCTION_DEVICE_REQUEST (0x0000u) +#define USB_FUNCTION_INTERFACE_REQUEST (0x0001u) +#define USB_FUNCTION_ENDPOINT_REQUEST (0x0002u) + +#define USB_FUNCTION_GETSTATUS_BUSPOWERD (0x0000u) +#define USB_FUNCTION_GETSTATUS_SELFPOWERD (0x0001u) +#define USB_FUNCTION_GETSTATUS_REMOTEWAKEUP (0x0002u) +#define USB_FUNCTION_GETSTATUS_NOTHALT (0x0000u) +#define USB_FUNCTION_GETSTATUS_HALT (0x0001u) + +#define USB_FUNCTION_FEATURE_ENDPOINT_HALT (0x0000u) +#define USB_FUNCTION_FEATURE_REMOTE_WAKEUP (0x0001u) +#define USB_FUNCTION_FEATURE_TEST_MODE (0x0002u) + +#define USB_FUNCTION_bRequest (0xff00u) /* b15-8:bRequest */ +#define USB_FUNCTION_bmRequestType (0x00ffu) /* b7-0: bmRequestType */ +#define USB_FUNCTION_bmRequestTypeDir (0x0080u) /* b7 : Data transfer direction */ +#define USB_FUNCTION_bmRequestTypeType (0x0060u) /* b6-5: Type */ +#define USB_FUNCTION_bmRequestTypeRecip (0x001fu) /* b4-0: Recipient */ + + +/******************************************************************************* +Variable Externs +*******************************************************************************/ + + +/******************************************************************************* +Functions Prototypes +*******************************************************************************/ +#if 0 +void R_USB_api_function_init(uint16_t root, uint8_t int_level, uint16_t mode, uint16_t clockmode); +uint16_t R_USB_api_function_IsConfigured(uint16_t root); +uint16_t R_USB_api_function_CtrlReadStart(uint16_t root, uint32_t size, uint8_t *data); +void R_USB_api_function_CtrlWriteStart(uint16_t root, uint32_t size, uint8_t *data); +uint16_t R_USB_api_function_start_send_transfer(uint16_t root, uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t R_USB_api_function_check_pipe_status(uint16_t root, uint16_t pipe, uint32_t *size); +void R_USB_api_function_clear_pipe_status(uint16_t root, uint16_t pipe); +void R_USB_api_function_start_receive_transfer(uint16_t root, uint16_t pipe, uint32_t size, uint8_t *data); +void R_USB_api_function_set_pid_buf(uint16_t root, uint16_t pipe); +void R_USB_api_function_set_pid_nak(uint16_t root, uint16_t pipe); +void R_USB_api_function_set_pid_stall(uint16_t root, uint16_t pipe); +void R_USB_api_function_clear_pid_stall(uint16_t root, uint16_t pipe); +uint16_t R_USB_api_function_get_pid(uint16_t root, uint16_t pipe); +int32_t R_USB_api_function_check_stall(uint16_t root, uint16_t pipe); +void R_USB_api_function_set_sqclr(uint16_t root, uint16_t pipe); +void R_USB_api_function_set_sqset(uint16_t root, uint16_t pipe); +void R_USB_api_function_set_csclr(uint16_t root, uint16_t pipe); +void R_USB_api_function_set_curpipe(uint16_t root, uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void R_USB_api_function_clear_brdy_sts(uint16_t root, uint16_t pipe); +void R_USB_api_function_clear_bemp_sts(uint16_t root, uint16_t pipe); +void R_USB_api_function_clear_nrdy_sts(uint16_t root, uint16_t pipe); +void R_USB_api_function_enable_brdy_int(uint16_t root, uint16_t pipe); +void R_USB_api_function_disable_brdy_int(uint16_t root, uint16_t pipe); +void R_USB_api_function_enable_bemp_int(uint16_t root, uint16_t pipe); +void R_USB_api_function_disable_bemp_int(uint16_t root, uint16_t pipe); +void R_USB_api_function_enable_nrdy_int(uint16_t root, uint16_t pipe); +void R_USB_api_function_disable_nrdy_int(uint16_t root, uint16_t pipe); +void R_USB_api_function_stop_transfer(uint16_t root, uint16_t pipe); +#endif + +#ifdef USB0_FUNCTION_API_H +void usb0_function_interrupt(uint32_t int_sense); +void usb0_function_dma_interrupt_d0fifo(uint32_t int_sense); +void usb0_function_dma_interrupt_d1fifo(uint32_t int_sense); + +void usb0_function_Class0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Class1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Class2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Class3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Class4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Class5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Vendor0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Vendor1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Vendor2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Vendor3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Vendor4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Vendor5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_ResetDescriptor(uint16_t mode); + +IRQn_Type Userdef_USB_usb0_function_d0fifo_dmaintid(void); +IRQn_Type Userdef_USB_usb0_function_d1fifo_dmaintid(void); +void Userdef_USB_usb0_function_attach(void); +void Userdef_USB_usb0_function_detach(void); +void Userdef_USB_usb0_function_delay_1ms(void); +void Userdef_USB_usb0_function_delay_xms(uint32_t msec); +void Userdef_USB_usb0_function_delay_10us(uint32_t usec); +void Userdef_USB_usb0_function_delay_500ns(void); +void Userdef_USB_usb0_function_start_dma(USB_FUNCTION_DMA_t *dma, uint16_t dfacc); +uint32_t Userdef_USB_usb0_function_stop_dma0(void); +uint32_t Userdef_USB_usb0_function_stop_dma1(void); + +void usb0_function_stop_transfer(uint16_t pipe); +void usb0_function_enable_brdy_int(uint16_t pipe); +void usb0_function_disable_brdy_int(uint16_t pipe); +void usb0_function_enable_bemp_int(uint16_t pipe); +void usb0_function_disable_bemp_int(uint16_t pipe); +void usb0_function_enable_nrdy_int(uint16_t pipe); +void usb0_function_disable_nrdy_int(uint16_t pipe); +#endif + +#ifdef USB1_FUNCTION_API_H +void usb1_function_interrupt(uint32_t int_sense); +void usb1_function_dma_interrupt_d0fifo(uint32_t int_sense); +void usb1_function_dma_interrupt_d1fifo(uint32_t int_sense); + +void usb1_function_Class0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Class1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Class2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Class3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Class4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Class5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Vendor0(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Vendor1(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Vendor2(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Vendor3(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Vendor4(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Vendor5(uint16_t type, uint16_t req, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_ResetDescriptor(uint16_t mode); + +uint16_t Userdef_USB_usb1_function_d0fifo_dmaintid(void); +uint16_t Userdef_USB_usb1_function_d1fifo_dmaintid(void); +void Userdef_USB_usb1_function_attach(void); +void Userdef_USB_usb1_function_detach(void); +void Userdef_USB_usb1_function_delay_1ms(void); +void Userdef_USB_usb1_function_delay_xms(uint32_t msec); +void Userdef_USB_usb1_function_delay_10us(uint32_t usec); +void Userdef_USB_usb1_function_delay_500ns(void); +void Userdef_USB_usb1_function_start_dma(USB_FUNCTION_DMA_t *dma, uint16_t dfacc); +uint32_t Userdef_USB_usb1_function_stop_dma0(void); +uint32_t Userdef_USB_usb1_function_stop_dma1(void); + +void usb1_function_stop_transfer(uint16_t pipe); +void usb1_function_enable_brdy_int(uint16_t pipe); +void usb1_function_disable_brdy_int(uint16_t pipe); +void usb1_function_enable_bemp_int(uint16_t pipe); +void usb1_function_disable_bemp_int(uint16_t pipe); +void usb1_function_enable_nrdy_int(uint16_t pipe); +void usb1_function_disable_nrdy_int(uint16_t pipe); +#endif + +#ifdef __cplusplus +} +#endif + + +#endif /* USB_FUNCTION_API_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h new file mode 100644 index 000000000..090e51c10 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h @@ -0,0 +1,143 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb_function.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB_FUNCTION_H +#define USB_FUNCTION_H + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "r_typedefs.h" +#include "iodefine.h" +#include "rza_io_regrw.h" + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +#define USB_FUNCTION_ALT_NO (255) +#define USB_FUNCTION_ALT_SET (0xff) + +#define USB_FUNCTION_BITUPLLE (0x0002u) +#define USB_FUNCTION_BITUCKSEL (0x0004u) +#define USB_FUNCTION_BITBWAIT (0x003fu) + +#define USB_FUNCTION_BUSWAIT_02 (0x0000u) +#define USB_FUNCTION_BUSWAIT_03 (0x0001u) +#define USB_FUNCTION_BUSWAIT_04 (0x0002u) +#define USB_FUNCTION_BUSWAIT_05 (0x0003u) +#define USB_FUNCTION_BUSWAIT_06 (0x0004u) +#define USB_FUNCTION_BUSWAIT_07 (0x0005u) +#define USB_FUNCTION_BUSWAIT_08 (0x0006u) +#define USB_FUNCTION_BUSWAIT_09 (0x0007u) +#define USB_FUNCTION_BUSWAIT_10 (0x0008u) +#define USB_FUNCTION_BUSWAIT_11 (0x0009u) +#define USB_FUNCTION_BUSWAIT_12 (0x000au) +#define USB_FUNCTION_BUSWAIT_13 (0x000bu) +#define USB_FUNCTION_BUSWAIT_14 (0x000cu) +#define USB_FUNCTION_BUSWAIT_15 (0x000du) +#define USB_FUNCTION_BUSWAIT_16 (0x000eu) +#define USB_FUNCTION_BUSWAIT_17 (0x000fu) + +#define USB_FUNCTION_BITRESUME (0x0020u) +#define USB_FUNCTION_BITUACT (0x0010u) +#define USB_FUNCTION_HSPROC (0x0004u) +#define USB_FUNCTION_HSMODE (0x0003u) +#define USB_FUNCTION_FSMODE (0x0002u) +#define USB_FUNCTION_LSMODE (0x0001u) +#define USB_FUNCTION_UNDECID (0x0000u) + +#define USB_FUNCTION_BITRCNT (0x8000u) +#define USB_FUNCTION_BITDREQE (0x1000u) +#define USB_FUNCTION_BITMBW (0x0c00u) +#define USB_FUNCTION_BITMBW_8 (0x0000u) +#define USB_FUNCTION_BITMBW_16 (0x0400u) +#define USB_FUNCTION_BITMBW_32 (0x0800u) +#define USB_FUNCTION_BITBYTE_LITTLE (0x0000u) +#define USB_FUNCTION_BITBYTE_BIG (0x0100u) +#define USB_FUNCTION_BITISEL (0x0020u) +#define USB_FUNCTION_BITCURPIPE (0x000fu) + +#define USB_FUNCTION_CFIFO_READ (0x0000u) +#define USB_FUNCTION_CFIFO_WRITE (0x0020u) + +#define USB_FUNCTION_BITBVAL (0x8000u) +#define USB_FUNCTION_BITBCLR (0x4000u) +#define USB_FUNCTION_BITFRDY (0x2000u) +#define USB_FUNCTION_BITDTLN (0x0fffu) + +#define USB_FUNCTION_BITVBSE (0x8000u) +#define USB_FUNCTION_BITRSME (0x4000u) +#define USB_FUNCTION_BITSOFE (0x2000u) +#define USB_FUNCTION_BITDVSE (0x1000u) +#define USB_FUNCTION_BITCTRE (0x0800u) +#define USB_FUNCTION_BITVBINT (0x8000u) +#define USB_FUNCTION_BITRESM (0x4000u) +#define USB_FUNCTION_BITSOFR (0x2000u) +#define USB_FUNCTION_BITDVST (0x1000u) +#define USB_FUNCTION_BITCTRT (0x0800u) + +#define USB_FUNCTION_BITBEMPE (0x0400u) +#define USB_FUNCTION_BITNRDYE (0x0200u) +#define USB_FUNCTION_BITBRDYE (0x0100u) +#define USB_FUNCTION_BITBEMP (0x0400u) +#define USB_FUNCTION_BITNRDY (0x0200u) +#define USB_FUNCTION_BITBRDY (0x0100u) + +#define USB_FUNCTION_BITDVSQ (0x0070u) +#define USB_FUNCTION_BITDVSQS (0x0030u) +#define USB_FUNCTION_DS_SPD_CNFG (0x0070u) +#define USB_FUNCTION_DS_SPD_ADDR (0x0060u) +#define USB_FUNCTION_DS_SPD_DFLT (0x0050u) +#define USB_FUNCTION_DS_SPD_POWR (0x0040u) +#define USB_FUNCTION_DS_CNFG (0x0030u) +#define USB_FUNCTION_DS_ADDS (0x0020u) +#define USB_FUNCTION_DS_DFLT (0x0010u) +#define USB_FUNCTION_DS_POWR (0x0000u) +#define USB_FUNCTION_BITVALID (0x0008u) +#define USB_FUNCTION_BITCTSQ (0x0007u) +#define USB_FUNCTION_CS_SQER (0x0006u) +#define USB_FUNCTION_CS_WRND (0x0005u) +#define USB_FUNCTION_CS_WRSS (0x0004u) +#define USB_FUNCTION_CS_WRDS (0x0003u) +#define USB_FUNCTION_CS_RDSS (0x0002u) +#define USB_FUNCTION_CS_RDDS (0x0001u) +#define USB_FUNCTION_CS_IDST (0x0000u) + +#define USB_FUNCTION_PIPExBUF (64u) + +#define USB_FUNCTION_D0FIFO (0) +#define USB_FUNCTION_D1FIFO (1) +#define USB_FUNCTION_DMA_READY (0) +#define USB_FUNCTION_DMA_BUSY (1) +#define USB_FUNCTION_DMA_BUSYEND (2) + +#define USB_FUNCTION_FIFO_USE (0x7000) + +#endif /* USB_FUNCTION_FUNCTION_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h new file mode 100644 index 000000000..d26e3b083 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h @@ -0,0 +1,32 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb_function_version.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ + +#define USB_FUNCTION_LOCAL_Rev "VER080_140709" + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function.h new file mode 100644 index 000000000..02855eb13 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function.h @@ -0,0 +1,171 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB0_FUNCTION_H +#define USB0_FUNCTION_H + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "devdrv_usb_function_api.h" +#include "usb_function.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ +extern const uint16_t g_usb0_function_bit_set[]; +extern uint32_t g_usb0_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint8_t *g_usb0_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1]; + +extern uint16_t g_usb0_function_PipeIgnore[]; +extern uint16_t g_usb0_function_PipeTbl[]; +extern uint16_t g_usb0_function_pipe_status[]; +extern uint32_t g_usb0_function_PipeDataSize[]; + +extern USB_FUNCTION_DMA_t g_usb0_function_DmaInfo[]; +extern uint16_t g_usb0_function_DmaPipe[]; +extern uint16_t g_usb0_function_DmaBval[]; +extern uint16_t g_usb0_function_DmaStatus[]; + +extern uint16_t g_usb0_function_CtrZeroLengthFlag; + +extern uint16_t g_usb0_function_ConfigNum; +extern uint16_t g_usb0_function_Alternate[USB_FUNCTION_ALT_NO]; +extern uint16_t g_usb0_function_RemoteWakeupFlag; +extern uint16_t g_usb0_function_TestModeFlag; +extern uint16_t g_usb0_function_TestModeSelectors; + +extern uint16_t g_usb0_function_ReqType; +extern uint16_t g_usb0_function_ReqTypeType; +extern uint16_t g_usb0_function_ReqTypeRecip; +extern uint16_t g_usb0_function_ReqRequest; +extern uint16_t g_usb0_function_ReqValue; +extern uint16_t g_usb0_function_ReqIndex; +extern uint16_t g_usb0_function_ReqLength; + +extern uint16_t g_usb0_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1]; + +extern uint16_t g_usb0_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint16_t g_usb0_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint16_t g_usb0_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint16_t g_usb0_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1]; + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +/* ==== common ==== */ +void usb0_function_dma_stop_d0(uint16_t pipe, uint32_t remain); +void usb0_function_dma_stop_d1(uint16_t pipe, uint32_t remain); +uint16_t usb0_function_is_hispeed(void); +uint16_t usb0_function_is_hispeed_enable(void); +uint16_t usb0_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t usb0_function_write_buffer(uint16_t pipe); +uint16_t usb0_function_write_buffer_c(uint16_t pipe); +uint16_t usb0_function_write_buffer_d0(uint16_t pipe); +uint16_t usb0_function_write_buffer_d1(uint16_t pipe); +void usb0_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t usb0_function_read_buffer(uint16_t pipe); +uint16_t usb0_function_read_buffer_c(uint16_t pipe); +uint16_t usb0_function_read_buffer_d0(uint16_t pipe); +uint16_t usb0_function_read_buffer_d1(uint16_t pipe); +uint16_t usb0_function_change_fifo_port(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void usb0_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void usb0_function_set_curpipe2(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc); +uint16_t usb0_function_get_mbw(uint32_t trncount, uint32_t dtptr); +uint16_t usb0_function_read_dma(uint16_t pipe); +void usb0_function_brdy_int(uint16_t status, uint16_t int_enb); +void usb0_function_nrdy_int(uint16_t status, uint16_t int_enb); +void usb0_function_bemp_int(uint16_t status, uint16_t int_enb); +void usb0_function_setting_interrupt(uint8_t level); +void usb0_function_reset_module(uint16_t clockmode); +uint16_t usb0_function_get_buf_size(uint16_t pipe); +uint16_t usb0_function_get_mxps(uint16_t pipe); +void usb0_function_clear_brdy_sts(uint16_t pipe); +void usb0_function_clear_bemp_sts(uint16_t pipe); +void usb0_function_clear_nrdy_sts(uint16_t pipe); +void usb0_function_set_pid_buf(uint16_t pipe); +void usb0_function_set_pid_nak(uint16_t pipe); +void usb0_function_set_pid_stall(uint16_t pipe); +void usb0_function_clear_pid_stall(uint16_t pipe); +uint16_t usb0_function_get_pid(uint16_t pipe); +void usb0_function_set_sqclr(uint16_t pipe); +void usb0_function_set_sqset(uint16_t pipe); +void usb0_function_set_csclr(uint16_t pipe); +void usb0_function_aclrm(uint16_t pipe); +void usb0_function_set_aclrm(uint16_t pipe); +void usb0_function_clr_aclrm(uint16_t pipe); +uint16_t usb0_function_get_sqmon(uint16_t pipe); +uint16_t usb0_function_get_inbuf(uint16_t pipe); + +/* ==== function ==== */ +void usb0_function_init_status(void); +void usb0_function_InitModule(uint16_t mode); +uint16_t usb0_function_CheckVBUStaus(void); +void usb0_function_USB_FUNCTION_Attach(void); +void usb0_function_USB_FUNCTION_Detach(void); +void usb0_function_USB_FUNCTION_BusReset(void); +void usb0_function_USB_FUNCTION_Resume(void); +void usb0_function_USB_FUNCTION_Suspend(void); +void usb0_function_USB_FUNCTION_TestMode(void); +void usb0_function_ResetDCP(void); +void usb0_function_ResetEP(uint16_t num); +uint16_t usb0_function_EpToPipe(uint16_t ep); +void usb0_function_InitEPTable(uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num); +uint16_t usb0_function_GetConfigNum(void); +uint16_t usb0_function_GetAltNum(uint16_t Con_Num, uint16_t Int_Num); +uint16_t usb0_function_CheckRemoteWakeup(void); +void usb0_function_clear_alt(void); +void usb0_function_clear_pipe_tbl(void); +void usb0_function_clear_ep_table_index(void); +uint16_t usb0_function_GetInterfaceNum(uint16_t num); + +#ifdef __cplusplus +} +#endif + + +#endif /* USB0_FUNCTION_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_api.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_api.h new file mode 100644 index 000000000..c33b3e63e --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_api.h @@ -0,0 +1,104 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_api.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB0_FUNCTION_API_H +#define USB0_FUNCTION_API_H + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Variable Externs +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +void usb0_api_function_init(uint8_t int_level, uint16_t mode, uint16_t clockmode); +uint16_t usb0_api_function_IsConfigured(void); +uint16_t usb0_function_GetDeviceState(void); +uint16_t usb0_api_function_CtrlReadStart(uint32_t size, uint8_t *data); +void usb0_api_function_CtrlWriteStart(uint32_t size, uint8_t *data); +uint16_t usb0_api_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t usb0_api_function_check_pipe_status(uint16_t pipe, uint32_t *size); +void usb0_api_function_clear_pipe_status(uint16_t pipe); +void usb0_api_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +void usb0_api_function_set_pid_buf(uint16_t pipe); +void usb0_api_function_set_pid_nak(uint16_t pipe); +void usb0_api_function_set_pid_stall(uint16_t pipe); +void usb0_api_function_clear_pid_stall(uint16_t pipe); +uint16_t usb0_api_function_get_pid(uint16_t pipe); +int32_t usb0_api_function_check_stall(uint16_t pipe); +void usb0_api_function_set_sqclr(uint16_t pipe); +void usb0_api_function_set_sqset(uint16_t pipe); +void usb0_api_function_set_csclr(uint16_t pipe); +void usb0_api_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void usb0_api_function_clear_brdy_sts(uint16_t pipe); +void usb0_api_function_clear_bemp_sts(uint16_t pipe); +void usb0_api_function_clear_nrdy_sts(uint16_t pipe); + +void usb0_function_ClearFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_SetFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_SetAddress(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_SetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_SetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_SetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_SynchFrame(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_GetStatus(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_GetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_GetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_GetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Resrv_0(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Resrv_123(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Resrv_4(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb0_function_Resrv_5(uint16_t type, uint16_t value, uint16_t index, uint16_t length); + +#ifdef __cplusplus +} +#endif + +#endif /* USB0_FUNCTION_API_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_dmacdrv.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_dmacdrv.h new file mode 100644 index 000000000..d74bac718 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_dmacdrv.h @@ -0,0 +1,142 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_dmacdrv.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB0_FUNCTION_DMACDRV_H +#define USB0_FUNCTION_DMACDRV_H + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ + + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ +typedef struct dmac_transinfo +{ + uint32_t src_addr; /* Transfer source address */ + uint32_t dst_addr; /* Transfer destination address */ + uint32_t count; /* Transfer byte count */ + uint32_t src_size; /* Transfer source data size */ + uint32_t dst_size; /* Transfer destination data size */ + uint32_t saddr_dir; /* Transfer source address direction */ + uint32_t daddr_dir; /* Transfer destination address direction */ +} dmac_transinfo_t; + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +/* ==== Transfer specification of the sample program ==== */ +#define DMAC_SAMPLE_SINGLE (0) /* Single transfer */ +#define DMAC_SAMPLE_CONTINUATION (1) /* Continuous transfer (use REN bit) */ + +/* ==== DMA modes ==== */ +#define DMAC_MODE_REGISTER (0) /* Register mode */ +#define DMAC_MODE_LINK (1) /* Link mode */ + +/* ==== Transfer requests ==== */ +#define DMAC_REQ_MODE_EXT (0) /* External request */ +#define DMAC_REQ_MODE_PERI (1) /* On-chip peripheral module request */ +#define DMAC_REQ_MODE_SOFT (2) /* Auto-request (request by software) */ + +/* ==== DMAC transfer sizes ==== */ +#define DMAC_TRANS_SIZE_8 (0) /* 8 bits */ +#define DMAC_TRANS_SIZE_16 (1) /* 16 bits */ +#define DMAC_TRANS_SIZE_32 (2) /* 32 bits */ +#define DMAC_TRANS_SIZE_64 (3) /* 64 bits */ +#define DMAC_TRANS_SIZE_128 (4) /* 128 bits */ +#define DMAC_TRANS_SIZE_256 (5) /* 256 bits */ +#define DMAC_TRANS_SIZE_512 (6) /* 512 bits */ +#define DMAC_TRANS_SIZE_1024 (7) /* 1024 bits */ + +/* ==== Address increment for transferring ==== */ +#define DMAC_TRANS_ADR_NO_INC (1) /* Not increment */ +#define DMAC_TRANS_ADR_INC (0) /* Increment */ + +/* ==== Method for detecting DMA request ==== */ +#define DMAC_REQ_DET_FALL (0) /* Falling edge detection */ +#define DMAC_REQ_DET_RISE (1) /* Rising edge detection */ +#define DMAC_REQ_DET_LOW (2) /* Low level detection */ +#define DMAC_REQ_DET_HIGH (3) /* High level detection */ + +/* ==== Request Direction ==== */ +#define DMAC_REQ_DIR_SRC (0) /* DMAREQ is the source/ DMAACK is active when reading */ +#define DMAC_REQ_DIR_DST (1) /* DMAREQ is the destination/ DMAACK is active when writing */ + +/* ==== Descriptors ==== */ +#define DMAC_DESC_HEADER (0) /* Header */ +#define DMAC_DESC_SRC_ADDR (1) /* Source Address */ +#define DMAC_DESC_DST_ADDR (2) /* Destination Address */ +#define DMAC_DESC_COUNT (3) /* Transaction Byte */ +#define DMAC_DESC_CHCFG (4) /* Channel Confg */ +#define DMAC_DESC_CHITVL (5) /* Channel Interval */ +#define DMAC_DESC_CHEXT (6) /* Channel Extension */ +#define DMAC_DESC_LINK_ADDR (7) /* Link Address */ + +/* ==== On-chip peripheral module requests ===== */ +typedef enum dmac_request_factor +{ + DMAC_REQ_USB0_DMA0_TX, /* USB_0 channel 0 transmit FIFO empty */ + DMAC_REQ_USB0_DMA0_RX, /* USB_0 channel 0 receive FIFO full */ + DMAC_REQ_USB0_DMA1_TX, /* USB_0 channel 1 transmit FIFO empty */ + DMAC_REQ_USB0_DMA1_RX, /* USB_0 channel 1 receive FIFO full */ + DMAC_REQ_USB1_DMA0_TX, /* USB_1 channel 0 transmit FIFO empty */ + DMAC_REQ_USB1_DMA0_RX, /* USB_1 channel 0 receive FIFO full */ + DMAC_REQ_USB1_DMA1_TX, /* USB_1 channel 1 transmit FIFO empty */ + DMAC_REQ_USB1_DMA1_RX, /* USB_1 channel 1 receive FIFO full */ +} dmac_request_factor_t; + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +void usb0_function_DMAC1_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction); +int32_t usb0_function_DMAC1_Open(uint32_t req); +void usb0_function_DMAC1_Close(uint32_t *remain); +void usb0_function_DMAC1_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count); + +void usb0_function_DMAC2_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction); +int32_t usb0_function_DMAC2_Open(uint32_t req); +void usb0_function_DMAC2_Close(uint32_t *remain); +void usb0_function_DMAC2_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count); + +#ifdef __cplusplus +} +#endif + +#endif /* USB0_FUNCTION_DMACDRV_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.c new file mode 100644 index 000000000..2f283c738 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.c @@ -0,0 +1,2933 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_dataio.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +static uint16_t g_usb0_function_mbw[(USB_FUNCTION_MAX_PIPE_NO + 1)]; + +static void usb0_function_start_receive_trns_c(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb0_function_start_receive_trns_d0(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb0_function_start_receive_trns_d1(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb0_function_start_receive_dma_d0(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb0_function_start_receive_dma_d1(uint16_t pipe, uint32_t size, uint8_t *data); +static uint16_t usb0_function_read_dma_d0(uint16_t pipe); +static uint16_t usb0_function_read_dma_d1(uint16_t pipe); +static uint16_t usb0_function_write_dma_d0(uint16_t pipe); +static uint16_t usb0_function_write_dma_d1(uint16_t pipe); + +static void usb0_function_read_c_fifo(uint16_t pipe, uint16_t count); +static void usb0_function_write_c_fifo(uint16_t Pipe, uint16_t count); +static void usb0_function_read_d0_fifo(uint16_t pipe, uint16_t count); +static void usb0_function_write_d0_fifo(uint16_t pipe, uint16_t count); +static void usb0_function_read_d1_fifo(uint16_t pipe, uint16_t count); +static void usb0_function_write_d1_fifo(uint16_t pipe, uint16_t count); + +static void usb0_function_clear_transaction_counter(uint16_t pipe); +static void usb0_function_set_transaction_counter(uint16_t pipe, uint32_t count); + +static uint32_t usb0_function_com_get_dmasize(uint32_t trncount, uint32_t dtptr); + +static uint16_t usb0_function_set_dfacc_d0(uint16_t mbw, uint32_t count); +static uint16_t usb0_function_set_dfacc_d1(uint16_t mbw, uint32_t count); + + +/******************************************************************************* +* Function Name: usb0_function_start_send_transfer +* Description : Starts the USB data communication using pipe specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t status; + uint16_t usefifo; + uint16_t mbw; + + g_usb0_function_data_count[pipe] = size; + g_usb0_function_data_pointer[pipe] = (uint8_t *)data; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + usb0_function_clear_bemp_sts(pipe); + usb0_function_clear_brdy_sts(pipe); + usb0_function_clear_nrdy_sts(pipe); + + mbw = usb0_function_get_mbw(size, (uint32_t)data); + + usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + case USB_FUNCTION_D0FIFO_DMA: + usefifo = USB_FUNCTION_D0USE; + break; + + case USB_FUNCTION_D1FIFO_USE: + case USB_FUNCTION_D1FIFO_DMA: + usefifo = USB_FUNCTION_D1USE; + break; + + default: + usefifo = USB_FUNCTION_CUSE; + break; + }; + + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, usefifo, DEVDRV_USBF_NO, mbw); + + usb0_function_clear_transaction_counter(pipe); + + usb0_function_aclrm(pipe); + + status = usb0_function_write_buffer(pipe); + + if (status != DEVDRV_USBF_FIFOERROR) + { + usb0_function_set_pid_buf(pipe); + } + + return status; +} + +/******************************************************************************* +* Function Name: usb0_function_write_buffer +* Description : Writes data in the buffer allocated in the pipe specified by +* : the argument. The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_write_buffer (uint16_t pipe) +{ + uint16_t status; + uint16_t usefifo; + + g_usb0_function_PipeIgnore[pipe] = 0; + usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + status = usb0_function_write_buffer_d0(pipe); + break; + + case USB_FUNCTION_D1FIFO_USE: + status = usb0_function_write_buffer_d1(pipe); + break; + + case USB_FUNCTION_D0FIFO_DMA: + status = usb0_function_write_dma_d0(pipe); + break; + + case USB_FUNCTION_D1FIFO_DMA: + status = usb0_function_write_dma_d1(pipe); + break; + + default: + status = usb0_function_write_buffer_c(pipe); + break; + }; + + switch (status) + { + case DEVDRV_USBF_WRITING: /* Continue of data write */ + usb0_function_enable_nrdy_int(pipe); /* Error (NORES or STALL) */ + usb0_function_enable_brdy_int(pipe); /* Enable Ready Interrupt */ + break; + + case DEVDRV_USBF_WRITEEND: /* End of data write */ + case DEVDRV_USBF_WRITESHRT: /* End of data write */ + usb0_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + usb0_function_clear_nrdy_sts(pipe); + usb0_function_enable_nrdy_int(pipe); /* Error (NORES or STALL) */ + /* for last transfer */ + usb0_function_enable_bemp_int(pipe); /* Enable Empty Interrupt */ + break; + + case DEVDRV_USBF_WRITEDMA: /* DMA write */ + usb0_function_clear_nrdy_sts(pipe); + usb0_function_enable_nrdy_int(pipe); /* Error (NORES or STALL) */ + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access status */ + default: + usb0_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + usb0_function_disable_bemp_int(pipe); /* Disable Empty Interrupt */ + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_write_buffer_c +* Description : Writes data in the buffer allocated in the pipe specified in +* : the argument. Writes data by CPU transfer using CFIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_write_buffer_c (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + if (g_usb0_function_CtrZeroLengthFlag == 1) + { + g_usb0_function_CtrZeroLengthFlag = 0; /* Zero Length Packet Flag CLR */ + return DEVDRV_USBF_WRITEEND; + } + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + if (pipe == USB_FUNCTION_PIPE0) + { + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw); + } + else + { + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw); + } + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] <= (uint32_t)size) + { + status = DEVDRV_USBF_WRITEEND; /* write continues */ + count = g_usb0_function_data_count[pipe]; + + if (count == 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Null Packet is end of write */ + } + + if ((count % mxps) != 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + } + else + { + status = DEVDRV_USBF_WRITING; /* write continues */ + count = (uint32_t)size; + } + + usb0_function_write_c_fifo(pipe, (uint16_t)count); + + if (g_usb0_function_data_count[pipe] < (uint32_t)size) + { + g_usb0_function_data_count[pipe] = 0; + + if (RZA_IO_RegRead_16(&USB200.CFIFOCTR, USB_CFIFOCTR_BVAL_SHIFT, USB_CFIFOCTR_BVAL) == 0) + { + USB200.CFIFOCTR = USB_FUNCTION_BITBVAL; /* Short Packet */ + g_usb0_function_CtrZeroLengthFlag = 1; /* Zero Length Packet Flag */ + } + } + else + { + g_usb0_function_data_count[pipe] -= count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_write_buffer_d0 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by CPU transfer using D0FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_write_buffer_d0 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] <= (uint32_t)size) + { + status = DEVDRV_USBF_WRITEEND; /* write continues */ + count = g_usb0_function_data_count[pipe]; + + if (count == 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Null Packet is end of write */ + } + + if ((count % mxps) != 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + } + else + { + status = DEVDRV_USBF_WRITING; /* write continues */ + count = (uint32_t)size; + } + + usb0_function_write_d0_fifo(pipe, (uint16_t)count); + + if (g_usb0_function_data_count[pipe] < (uint32_t)size) + { + g_usb0_function_data_count[pipe] = 0; + if (RZA_IO_RegRead_16(&USB200.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + USB200.D0FIFOCTR = USB_FUNCTION_BITBVAL; /* Short Packet */ + } + } + else + { + g_usb0_function_data_count[pipe] -= count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_write_buffer_d1 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by CPU transfer using D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_write_buffer_d1 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] <= (uint32_t)size) + { + status = DEVDRV_USBF_WRITEEND; /* write continues */ + count = g_usb0_function_data_count[pipe]; + + if (count == 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Null Packet is end of write */ + } + + if ((count % mxps) != 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + } + else + { + status = DEVDRV_USBF_WRITING; /* write continues */ + count = (uint32_t)size; + } + + usb0_function_write_d1_fifo(pipe, (uint16_t)count); + + if (g_usb0_function_data_count[pipe] < (uint32_t)size) + { + g_usb0_function_data_count[pipe] = 0; + + if (RZA_IO_RegRead_16(&USB200.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + USB200.D1FIFOCTR = USB_FUNCTION_BITBVAL; /* Short Packet */ + } + } + else + { + g_usb0_function_data_count[pipe] -= count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_write_dma_d0 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by DMA transfer using D0FIFO. +* : The DMA-ch for using is specified by Userdef_USB_usb0_function_start_dma(). +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND : Write end +* : DEVDRV_USBF_WRITESHRT : short data +* : DEVDRV_USBF_WRITING : Continue of data write +* : DEVDRV_USBF_WRITEDMA : Write DMA +* : DEVDRV_USBF_FIFOERROR : FIFO status +*******************************************************************************/ +static uint16_t usb0_function_write_dma_d0 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t status; + uint16_t mbw; + uint16_t dfacc = 0; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + count = g_usb0_function_data_count[pipe]; + + if (count != 0) + { + g_usb0_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe; + + if ((count % size) != 0) + { + g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 1; + } + else + { + g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 0; + } + + dfacc = usb0_function_set_dfacc_d0(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0; /* 8bit transfer */ + } + + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo = USB_FUNCTION_D0FIFO_DMA; + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].dir = USB_FUNCTION_BUF2FIFO; + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe]; + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes = count; + + Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc); + + usb0_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); + + g_usb0_function_data_count[pipe] = 0; + g_usb0_function_data_pointer[pipe] += count; + status = DEVDRV_USBF_WRITEDMA; /* DMA write */ + } + else + { + if (RZA_IO_RegRead_16(&USB200.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + RZA_IO_RegWrite_16(&USB200.D0FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */ + } + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_write_dma_d1 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by DMA transfer using D1FIFO. +* : The DMA-ch for using is specified by Userdef_USB_usb0_function_start_dma(). +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND : Write end +* : DEVDRV_USBF_WRITESHRT : short data +* : DEVDRV_USBF_WRITING : Continue of data write +* : DEVDRV_USBF_WRITEDMA : Write DMA +* : DEVDRV_USBF_FIFOERROR : FIFO status +*******************************************************************************/ +static uint16_t usb0_function_write_dma_d1 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t status; + uint16_t mbw; + uint16_t dfacc=0; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + count = g_usb0_function_data_count[pipe]; + + if (count != 0) + { + g_usb0_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe; + if ((count % size) != 0) + { + g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 1; + } + else + { + g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 0; + } + + dfacc = usb0_function_set_dfacc_d1(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0; /* 8bit transfer */ + } + + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo = USB_FUNCTION_D1FIFO_DMA; + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].dir = USB_FUNCTION_BUF2FIFO; + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe]; + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes = count; + + Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc); + + usb0_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); + + g_usb0_function_data_count[pipe] = 0; + g_usb0_function_data_pointer[pipe] += count; + + status = DEVDRV_USBF_WRITEDMA; /* DMA write */ + } + else + { + if (RZA_IO_RegRead_16(&USB200.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + RZA_IO_RegWrite_16(&USB200.D1FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */ + } + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_start_receive_transfer +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +void usb0_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t usefifo; + + usb0_function_clear_bemp_sts(pipe); + usb0_function_clear_brdy_sts(pipe); + usb0_function_clear_nrdy_sts(pipe); + + usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + usb0_function_start_receive_trns_d0(pipe, size, data); + break; + + case USB_FUNCTION_D1FIFO_USE: + usb0_function_start_receive_trns_d1(pipe, size, data); + break; + + case USB_FUNCTION_D0FIFO_DMA: + usb0_function_start_receive_dma_d0(pipe, size, data); + break; + + case USB_FUNCTION_D1FIFO_DMA: + usb0_function_start_receive_dma_d1(pipe, size, data); + break; + + default: + usb0_function_start_receive_trns_c(pipe, size, data); + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_start_receive_trns_c +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using CFIFO. +* : When storing data in the buffer allocated in the pipe specified in the +* : argument, BRDY interrupt is generated to read data +* : in the interrupt. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb0_function_start_receive_trns_c (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb0_function_set_pid_nak(pipe); + g_usb0_function_data_count[pipe] = size; + g_usb0_function_data_pointer[pipe] = (uint8_t *)data; + g_usb0_function_PipeIgnore[pipe] = 0; + + g_usb0_function_PipeDataSize[pipe] = size; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb0_function_get_mbw(size, (uint32_t)data); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw); + USB200.CFIFOCTR = USB_FUNCTION_BITBCLR; + + usb0_function_set_transaction_counter(pipe, size); + + usb0_function_aclrm(pipe); + + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + + usb0_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_start_receive_trns_d0 +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using D0FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, BRDY interrupt is generated to read data in the +* : interrupt. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb0_function_start_receive_trns_d0 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb0_function_set_pid_nak(pipe); + g_usb0_function_data_count[pipe] = size; + g_usb0_function_data_pointer[pipe] = (uint8_t *)data; + g_usb0_function_PipeIgnore[pipe] = 0; + + g_usb0_function_PipeDataSize[pipe] = size; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb0_function_get_mbw(size, (uint32_t)data); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + + usb0_function_set_transaction_counter(pipe, size); + + usb0_function_aclrm(pipe); + + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + + usb0_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_start_receive_trns_d1 +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using D1FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, BRDY interrupt is generated to read data. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb0_function_start_receive_trns_d1 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb0_function_set_pid_nak(pipe); + g_usb0_function_data_count[pipe] = size; + g_usb0_function_data_pointer[pipe] = (uint8_t *)data; + g_usb0_function_PipeIgnore[pipe] = 0; + + g_usb0_function_PipeDataSize[pipe] = size; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb0_function_get_mbw(size, (uint32_t)data); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + usb0_function_set_transaction_counter(pipe, size); + + usb0_function_aclrm(pipe); + + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + + usb0_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_start_receive_dma_d0 +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by DMA transfer using D0FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, delivered read request to DMAC to read data from +* : the buffer by DMAC. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb0_function_start_receive_dma_d0 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb0_function_set_pid_nak(pipe); + g_usb0_function_data_count[pipe] = size; + g_usb0_function_data_pointer[pipe] = (uint8_t *)data; + g_usb0_function_PipeIgnore[pipe] = 0; + + g_usb0_function_PipeDataSize[pipe] = 0; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb0_function_get_mbw(size, (uint32_t)data); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + + usb0_function_set_transaction_counter(pipe, size); + + usb0_function_aclrm(pipe); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + usb0_function_read_dma(pipe); + + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + } + else + { + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + } + + usb0_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_start_receive_dma_d1 +* Description : Read data from the buffer allocated in the pipe specified in the argument. +* : Reads data by DMA transfer using D0FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, delivered read request to DMAC to read data from +* : the buffer by DMAC. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb0_function_start_receive_dma_d1 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb0_function_set_pid_nak(pipe); + g_usb0_function_data_count[pipe] = size; + g_usb0_function_data_pointer[pipe] = (uint8_t *)data; + g_usb0_function_PipeIgnore[pipe] = 0; + + g_usb0_function_PipeDataSize[pipe] = 0; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb0_function_get_mbw(size, (uint32_t)data); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + usb0_function_set_transaction_counter(pipe, size); + + usb0_function_aclrm(pipe); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + usb0_function_read_dma(pipe); + + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + } + else + { + usb0_function_enable_nrdy_int(pipe); + usb0_function_enable_brdy_int(pipe); + } + + usb0_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_read_buffer +* Description : Reads data from the buffer allocated in the pipe specified +* : in the argument. +* : Uses FIF0 set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_read_buffer (uint16_t pipe) +{ + uint16_t status; + + g_usb0_function_PipeIgnore[pipe] = 0; + + if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE) + { + status = usb0_function_read_buffer_d0(pipe); + } + else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE) + { + status = usb0_function_read_buffer_d1(pipe); + } + else + { + status = usb0_function_read_buffer_c(pipe); + } + + switch (status) + { + case USB_FUNCTION_READING: /* Continue of data read */ + break; + + case USB_FUNCTION_READEND: /* End of data read */ + case USB_FUNCTION_READSHRT: /* End of data read */ + usb0_function_disable_brdy_int(pipe); + g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe]; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + break; + + case USB_FUNCTION_READOVER: /* buffer over */ + if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE) + { + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE) + { + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + USB200.CFIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + usb0_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe]; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access status */ + default: + usb0_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_read_buffer_c +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using CFIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_read_buffer_c (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + usb0_function_set_pid_nak(pipe); /* Set NAK */ + count = g_usb0_function_data_count[pipe]; + } + else if (g_usb0_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + usb0_function_set_pid_nak(pipe); /* Set NAK */ + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + } + + if (count == 0) /* 0 length packet */ + { + USB200.CFIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + usb0_function_read_c_fifo(pipe, (uint16_t)count); + } + + g_usb0_function_data_count[pipe] -= count; + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_read_buffer_d0 +* Description : Reads data from the buffer allocated in the pipe specified in +* : the argument. +* : Reads data by CPU transfer using D0FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_read_buffer_d0 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t pipebuf_size; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + usb0_function_set_pid_nak(pipe); /* Set NAK */ + count = g_usb0_function_data_count[pipe]; + } + else if (g_usb0_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + usb0_function_set_pid_nak(pipe); /* Set NAK */ + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + else + { + pipebuf_size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + } + } + + if (count == 0) /* 0 length packet */ + { + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + usb0_function_read_d0_fifo(pipe, (uint16_t)count); + } + + g_usb0_function_data_count[pipe] -= count; + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_read_buffer_d1 +* Description : Reads data from the buffer allocated in the pipe specified +* : in the argument. +* : Reads data by CPU transfer using D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_read_buffer_d1 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t pipebuf_size; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + usb0_function_set_pid_nak(pipe); /* Set NAK */ + count = g_usb0_function_data_count[pipe]; + } + else if (g_usb0_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + usb0_function_set_pid_nak(pipe); /* Set NAK */ + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + else + { + pipebuf_size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb0_function_set_pid_nak(pipe); /* Set NAK */ + } + } + } + + if (count == 0) /* 0 length packet */ + { + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + usb0_function_read_d1_fifo(pipe, (uint16_t)count); + } + + g_usb0_function_data_count[pipe] -= count; + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_read_dma +* Description : Reads data from the buffer allocated in the pipe specified +* : in the argument. +* : Reads data by DMA transfer using D0FIFO or D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_function_read_dma (uint16_t pipe) +{ + uint16_t status; + + g_usb0_function_PipeIgnore[pipe] = 0; + if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) + { + status = usb0_function_read_dma_d0(pipe); + } + else + { + status = usb0_function_read_dma_d1(pipe); + } + + switch (status) + { + case USB_FUNCTION_READING: /* Continue of data read */ + break; + + case USB_FUNCTION_READZERO: /* End of data read */ + usb0_function_disable_brdy_int(pipe); + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + break; + + case USB_FUNCTION_READEND: /* End of data read */ + case USB_FUNCTION_READSHRT: /* End of data read */ + usb0_function_disable_brdy_int(pipe); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe]; + } + break; + + case USB_FUNCTION_READOVER: /* buffer over */ + usb0_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + g_usb0_function_PipeDataSize[pipe] -= g_usb0_function_data_count[pipe]; + } + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access status */ + default: + usb0_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_read_dma_d0 +* Description : Writes data in the buffer allocated in the pipe specified +* : in the argument. +* : Reads data by DMA transfer using D0FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READZERO ; zero data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +static uint16_t usb0_function_read_dma_d0 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t dfacc = 0; + uint16_t pipebuf_size; + + g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + count = g_usb0_function_data_count[pipe]; + status = USB_FUNCTION_READING; + } + else + { + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + count = g_usb0_function_data_count[pipe]; + } + else if (g_usb0_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + else + { + pipebuf_size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + } + } + + if (count == 0) /* 0 length packet */ + { + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + status = USB_FUNCTION_READZERO; /* Null Packet receive */ + } + else + { + usb0_function_set_curpipe(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw); + /* transaction counter No set */ + /* FRDY = 1, DTLN = 0 -> BRDY */ + } + } + else + { + dfacc = usb0_function_set_dfacc_d0(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0; /* 8bit transfer */ + } + + g_usb0_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe; /* not use in read operation */ + g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] = 0; /* not use in read operation */ + + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo = USB_FUNCTION_D0FIFO_DMA; + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].dir = USB_FUNCTION_FIFO2BUF; + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe]; + g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes = count; + + if (status == USB_FUNCTION_READING) + { + g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSY; + } + else + { + g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSYEND; + } + + Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc); + + usb0_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, + 1, + USB_DnFIFOSEL_DREQE_SHIFT, + USB_DnFIFOSEL_DREQE); + } + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + g_usb0_function_data_count[pipe] -= count; + g_usb0_function_data_pointer[pipe] += count; + g_usb0_function_PipeDataSize[pipe] += count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_read_dma_d1 +* Description : Reads data from the buffer allocated in the pipe specified in +* : the argument. +* : Reads data by DMA transfer using D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READZERO ; zero data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +static uint16_t usb0_function_read_dma_d1 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t dfacc=0; + uint16_t pipebuf_size; + + g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[pipe], (uint32_t)g_usb0_function_data_pointer[pipe]); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + count = g_usb0_function_data_count[pipe]; + status = USB_FUNCTION_READING; + } + else + { + buffer = usb0_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw); + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb0_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + count = g_usb0_function_data_count[pipe]; + } + else if (g_usb0_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + else + { + pipebuf_size = usb0_function_get_buf_size(pipe); /* Data buffer size */ + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + } + } + + if (count == 0) /* 0 length packet */ + { + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + status = USB_FUNCTION_READZERO; /* Null Packet receive */ + } + else + { + usb0_function_set_curpipe(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw); + /* transaction counter No set */ + /* FRDY = 1, DTLN = 0 -> BRDY */ + } + } + else + { + dfacc = usb0_function_set_dfacc_d1(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0; /* 8bit transfer */ + } + + g_usb0_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe; /* not use in read operation */ + g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] = 0; /* not use in read operation */ + + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo = USB_FUNCTION_D1FIFO_DMA; + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].dir = USB_FUNCTION_FIFO2BUF; + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb0_function_data_pointer[pipe]; + g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes = count; + + if (status == USB_FUNCTION_READING) + { + g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSY; + } + else + { + g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSYEND; + } + + Userdef_USB_usb0_function_start_dma(&g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc); + + usb0_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, + 1, + USB_DnFIFOSEL_DREQE_SHIFT, + USB_DnFIFOSEL_DREQE); + } + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + g_usb0_function_data_count[pipe] -= count; + g_usb0_function_data_pointer[pipe] += count; + g_usb0_function_PipeDataSize[pipe] += count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_function_change_fifo_port +* Description : Allocates FIF0 specified by the argument in the pipe assigned +* : by the argument. After allocating FIF0, waits in the software +* : till the corresponding pipe becomes ready. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* Return Value : DEVDRV_USBF_FIFOERROR ; Error +* : Others ; CFIFOCTR/D0FIFOCTR/D1FIFOCTR Register Value +*******************************************************************************/ +uint16_t usb0_function_change_fifo_port (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw) +{ + uint16_t buffer; + uint32_t loop; + volatile uint32_t loop2; + + usb0_function_set_curpipe(pipe, fifosel, isel, mbw); + + for (loop = 0; loop < 4; loop++) + { + switch (fifosel) + { + case USB_FUNCTION_CUSE: + buffer = USB200.CFIFOCTR; + break; + + case USB_FUNCTION_D0USE: + case USB_FUNCTION_D0DMA: + buffer = USB200.D0FIFOCTR; + break; + + case USB_FUNCTION_D1USE: + case USB_FUNCTION_D1DMA: + buffer = USB200.D1FIFOCTR; + break; + + default: + buffer = 0; + break; + } + + if ((buffer & USB_FUNCTION_BITFRDY) == USB_FUNCTION_BITFRDY) + { + return buffer; + } + + loop2 = 25; + while (loop2-- > 0) + { + /* wait */ + } + } + + return DEVDRV_USBF_FIFOERROR; +} + +/******************************************************************************* +* Function Name: usb0_function_set_curpipe +* Description : Allocates FIF0 specified by the argument in the pipe assigned +* : by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* Return Value : none +*******************************************************************************/ +void usb0_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw) +{ + uint16_t buffer; + uint32_t loop; + volatile uint32_t loop2; + + g_usb0_function_mbw[pipe] = mbw; + + switch (fifosel) + { + case USB_FUNCTION_CUSE: + buffer = USB200.CFIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE); + buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL); + USB200.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(isel | pipe | mbw); + USB200.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D0DMA: + case USB_FUNCTION_D0USE: + buffer = USB200.D0FIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); + USB200.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB200.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D1DMA: + case USB_FUNCTION_D1USE: + buffer = USB200.D1FIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); + USB200.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB200.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + default: + break; + } + + /* Cautions !!! + * Depending on the external bus speed of CPU, you may need to wait for 450ns here. + * For details, please look at the data sheet. */ + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } +} + +/******************************************************************************* +* Function Name: usb0_function_set_curpipe2 +* Description : Allocates FIF0 specified by the argument in the pipe assigned +* : by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* : uint16_t dfacc ; DFACC Access mode +* Return Value : none +*******************************************************************************/ +void usb0_function_set_curpipe2 (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc) +{ + uint16_t buffer; + uint32_t loop; +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + uint32_t dummy; +#endif + volatile uint32_t loop2; + + g_usb0_function_mbw[pipe] = mbw; + + switch (fifosel) + { + case USB_FUNCTION_CUSE: + buffer = USB200.CFIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE); + buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL); + USB200.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(isel | pipe | mbw); + USB200.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D0DMA: + case USB_FUNCTION_D0USE: + buffer = USB200.D0FIFOSEL; +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + + if (dfacc != 0) + { + buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32); + } +#else + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); +#endif + USB200.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dfacc != 0) + { + dummy = USB200.D0FIFO.UINT32; + } +#endif + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB200.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D1DMA: + case USB_FUNCTION_D1USE: + buffer = USB200.D1FIFOSEL; +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + + if (dfacc != 0) + { + buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32); + } +#else + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); +#endif + USB200.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dfacc != 0) + { + dummy = USB200.D1FIFO.UINT32; + loop = dummy; // avoid warning. + } +#endif + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB200.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB200.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + default: + break; + } + + /* Cautions !!! + * Depending on the external bus speed of CPU, you may need to wait for 450ns here. + * For details, please look at the data sheet. */ + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } +} + +/******************************************************************************* +* Function Name: usb0_function_write_c_fifo +* Description : Writes data in CFIFO. +* : Writes data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating CFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb0_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb0_function_write_c_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + USB200.CFIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe]; + g_usb0_function_data_pointer[pipe] += 1; + } + } + else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)(count / 2); even; --even) + { + USB200.CFIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]); + g_usb0_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)(count / 4); even; --even) + { + USB200.CFIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]); + g_usb0_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_read_c_fifo +* Description : Reads data from CFIFO. +* : Reads data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating CFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb0_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb0_function_read_c_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + *g_usb0_function_data_pointer[pipe] = USB200.CFIFO.UINT8[HH]; + g_usb0_function_data_pointer[pipe] += 1; + } + } + else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)((count + 1) / 2); even; --even) + { + *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.CFIFO.UINT16[H]; + g_usb0_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)((count + 3) / 4); even; --even) + { + *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.CFIFO.UINT32; + g_usb0_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_write_d0_fifo +* Description : Writes data in D0FIFO. +* : Writes data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating CFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb0_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb0_function_write_d0_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + USB200.D0FIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe]; + g_usb0_function_data_pointer[pipe] += 1; + } + } + else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)(count / 2); even; --even) + { + USB200.D0FIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]); + g_usb0_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)(count / 4); even; --even) + { + USB200.D0FIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]); + g_usb0_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_read_d0_fifo +* Description : Reads data from D0FIFO. +* : Reads data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating DOFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb0_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb0_function_read_d0_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + *g_usb0_function_data_pointer[pipe] = USB200.D0FIFO.UINT8[HH]; + g_usb0_function_data_pointer[pipe] += 1; + } + } + else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)((count + 1) / 2); even; --even) + { + *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.D0FIFO.UINT16[H]; + g_usb0_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)((count + 3) / 4); even; --even) + { + *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.D0FIFO.UINT32; + g_usb0_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_write_d1_fifo +* Description : Writes data in D1FIFO. +* : Writes data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating D1FIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb0_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb0_function_write_d1_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + USB200.D1FIFO.UINT8[HH] = *g_usb0_function_data_pointer[pipe]; + g_usb0_function_data_pointer[pipe] += 1; + } + } + else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)(count / 2); even; --even) + { + USB200.D1FIFO.UINT16[H] = *((uint16_t *)g_usb0_function_data_pointer[pipe]); + g_usb0_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)(count / 4); even; --even) + { + USB200.D1FIFO.UINT32 = *((uint32_t *)g_usb0_function_data_pointer[pipe]); + g_usb0_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_read_d1_fifo +* Description : Reads data from D1FIFO. +* : Reads data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating D1FIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb0_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb0_function_read_d1_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + *g_usb0_function_data_pointer[pipe] = USB200.D1FIFO.UINT8[HH]; + g_usb0_function_data_pointer[pipe] += 1; + } + } + else if (g_usb0_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)((count + 1) / 2); even; --even) + { + *((uint16_t *)g_usb0_function_data_pointer[pipe]) = USB200.D1FIFO.UINT16[H]; + g_usb0_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)((count + 3) / 4); even; --even) + { + *((uint32_t *)g_usb0_function_data_pointer[pipe]) = USB200.D1FIFO.UINT32; + g_usb0_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_com_get_dmasize +* Description : Calculates access width of DMA transfer by the argument to +* : return as the Return Value. +* Arguments : uint32_t trncount : transfer byte +* : uint32_t dtptr : transfer data pointer +* Return Value : DMA transfer size : 0 8bit +* : : 1 16bit +* : : 2 32bit +*******************************************************************************/ +static uint32_t usb0_function_com_get_dmasize (uint32_t trncount, uint32_t dtptr) +{ + uint32_t size; + + if (((trncount & 0x0001) != 0) || ((dtptr & 0x00000001) != 0)) + { + /* When transfer byte count is odd */ + /* or transfer data area is 8-bit alignment */ + size = 0; /* 8bit */ + } + else if (((trncount & 0x0003) != 0) || ((dtptr & 0x00000003) != 0)) + { + /* When the transfer byte count is multiples of 2 */ + /* or the transfer data area is 16-bit alignment */ + size = 1; /* 16bit */ + } + else + { + /* When the transfer byte count is multiples of 4 */ + /* or the transfer data area is 32-bit alignment */ + size = 2; /* 32bit */ + } + + return size; +} + +/******************************************************************************* +* Function Name: usb0_function_get_mbw +* Description : Calculates access width of DMA to return the value set in MBW. +* Arguments : uint32_t trncount : transfer byte +* : uint32_t dtptr : transfer data pointer +* Return Value : FIFO transfer size : USB_FUNCTION_BITMBW_8 8bit +* : : USB_FUNCTION_BITMBW_16 16bit +* : : USB_FUNCTION_BITMBW_32 32bit +*******************************************************************************/ +uint16_t usb0_function_get_mbw (uint32_t trncount, uint32_t dtptr) +{ + uint32_t size; + uint16_t mbw; + + size = usb0_function_com_get_dmasize(trncount, dtptr); + + if (size == 0) + { + /* 8bit */ + mbw = USB_FUNCTION_BITMBW_8; + } + else if (size == 1) + { + /* 16bit */ + mbw = USB_FUNCTION_BITMBW_16; + } + else + { + /* 32bit */ + mbw = USB_FUNCTION_BITMBW_32; + } + + return mbw; +} + +/******************************************************************************* +* Function Name: usb0_function_set_transaction_counter +* Description : Sets transaction counter by the argument(PIPEnTRN). +* : Clears transaction before setting to enable transaction counter setting. +* Arguments : uint16_t pipe ; Pipe number +* : uint32_t bsize : Data transfer size +* Return Value : none +*******************************************************************************/ +static void usb0_function_set_transaction_counter (uint16_t pipe, uint32_t bsize) +{ + uint16_t mxps; + uint16_t cnt; + + if (bsize == 0) + { + return; + } + + mxps = usb0_function_get_mxps(pipe); /* Max Packet Size */ + + if ((bsize % mxps) == 0) + { + cnt = (uint16_t)(bsize / mxps); + } + else + { + cnt = (uint16_t)((bsize / mxps) + 1); + } + + switch (pipe) + { + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPE1TRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPE1TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPE2TRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPE2TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPE3TRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPE3TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPE4TRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPE4TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPE5TRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPE5TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPE9TRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPE9TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEATRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPEATRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPEATRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPEBTRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPEBTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPECTRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPECTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPEDTRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPEDTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEETRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPEETRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPEETRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB200.PIPEFTRN = cnt; + RZA_IO_RegWrite_16(&USB200.PIPEFTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_clear_transaction_counter +* Description : Clears the transaction counter by the argument. +* : After executing this function, the transaction counter is invalid. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb0_function_clear_transaction_counter (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPE1TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPE2TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPE3TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPE4TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPE5TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPE9TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEATRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPEATRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPEBTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPECTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPEDTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEETRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPEETRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB200.PIPEFTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_stop_transfer +* Description : Stops the USB transfer in the pipe specified by the argument. +* : After stopping the USB transfer, clears the buffer allocated in +* : the pipe. +* : After executing this function, allocation in FIF0 becomes USB_FUNCTION_PIPE0; +* : invalid. After executing this function, BRDY/NRDY/BEMP interrupt +* : in the corresponding pipe becomes invalid. Sequence bit is also +* : cleared. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_stop_transfer (uint16_t pipe) +{ + uint16_t usefifo; + uint32_t remain; + uint16_t fifo; + + usb0_function_set_pid_nak(pipe); + + usefifo = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + usb0_function_clear_transaction_counter(pipe); + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D0USE; + break; + + case USB_FUNCTION_D1FIFO_USE: + usb0_function_clear_transaction_counter(pipe); + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D1USE; + break; + + case USB_FUNCTION_D0FIFO_DMA: + remain = Userdef_USB_usb0_function_stop_dma0(); + usb0_function_dma_stop_d0(pipe, remain); + usb0_function_clear_transaction_counter(pipe); + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D0DMA; + break; + + case USB_FUNCTION_D1FIFO_DMA: + remain = Userdef_USB_usb0_function_stop_dma1(); + usb0_function_dma_stop_d1(pipe, remain); + usb0_function_clear_transaction_counter(pipe); + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D1DMA; + break; + + default: + usb0_function_clear_transaction_counter(pipe); + USB200.CFIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_CUSE; + break; + } + + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, fifo, DEVDRV_USBF_NO, USB_FUNCTION_BITMBW_16); + + /* Interrupt of pipe set is disabled */ + usb0_function_disable_brdy_int(pipe); + usb0_function_disable_nrdy_int(pipe); + usb0_function_disable_bemp_int(pipe); + + usb0_function_aclrm(pipe); + usb0_function_set_csclr(pipe); + + if ( g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT ) + { + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES; + } + +} + +/******************************************************************************* +* Function Name: usb0_function_set_dfacc_d0 +* Description : Sets the DFACC setting value in D0FIFO using the transfer size. +* Arguments : uint16_t mbw ; MBW +* : uint16_t count ; data count +* Return Value : DFACC Access mode +*******************************************************************************/ +static uint16_t usb0_function_set_dfacc_d0 (uint16_t mbw, uint32_t count) +{ + uint16_t dfacc = 0; + +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; +#else + if (mbw == USB_FUNCTION_BITMBW_32) + { + if ((count % 32) == 0) + { + /* 32byte transfer */ + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 2, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 2; + } + else if ((count % 16) == 0) + { + /* 16byte transfer */ + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 1, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 1; + } + else + { + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + else + { + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } +#endif + return dfacc; +} + +/******************************************************************************* +* Function Name: usb0_function_set_dfacc_d1 +* Description : Set the DFACC setting value in D1FIFO using the transfer size. +* Arguments : uint16_t mbw ; MBW +* : uint16_t count ; data count +* Return Value : DFACC Access mode +*******************************************************************************/ +static uint16_t usb0_function_set_dfacc_d1 (uint16_t mbw, uint32_t count) +{ + uint16_t dfacc = 0; + +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; +#else + if (mbw == USB_FUNCTION_BITMBW_32) + { + if ((count % 32) == 0) + { + /* 32byte transfer */ + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 2, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 2; + } + else if ((count % 16) == 0) + { + /* 16byte transfer */ + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 1, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 1; + } + else + { + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + else + { + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB200.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } +#endif + + return dfacc; +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dma.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dma.c new file mode 100644 index 000000000..cfc8d0f49 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dma.c @@ -0,0 +1,346 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_dma.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +static void usb0_function_dmaint(uint16_t fifo); +static void usb0_function_dmaint_buf2fifo(uint16_t pipe); +static void usb0_function_dmaint_fifo2buf(uint16_t pipe); + + +/******************************************************************************* +* Function Name: usb0_function_dma_stop_d0 +* Description : D0FIFO DMA stop +* Arguments : uint16_t pipe : pipe number +* : uint32_t remain : transfer byte +* Return Value : none +*******************************************************************************/ +void usb0_function_dma_stop_d0 (uint16_t pipe, uint32_t remain) +{ + uint16_t dtln; + uint16_t dfacc; + uint16_t buffer; + uint16_t sds_b = 1; + + dfacc = RZA_IO_RegRead_16(&USB200.D0FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC); + + if (dfacc == 2) + { + sds_b = 32; + } + else if (dfacc == 1) + { + sds_b = 16; + } + else + { + if (g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 2) + { + sds_b = 4; + } + else if (g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 1) + { + sds_b = 2; + } + else + { + sds_b = 1; + } + } + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE) + { + buffer = USB200.D0FIFOCTR; + dtln = (buffer & USB_FUNCTION_BITDTLN); + + if ((dtln % sds_b) != 0) + { + remain += (sds_b - (dtln % sds_b)); + } + g_usb0_function_PipeDataSize[pipe] = (g_usb0_function_data_count[pipe] - remain); + g_usb0_function_data_count[pipe] = remain; + } + } + + RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); +} + +/******************************************************************************* +* Function Name: usb0_function_dma_stop_d1 +* Description : D1FIFO DMA stop +* Arguments : uint16_t pipe : pipe number +* : uint32_t remain : transfer byte +* Return Value : none +*******************************************************************************/ +void usb0_function_dma_stop_d1 (uint16_t pipe, uint32_t remain) +{ + uint16_t dtln; + uint16_t dfacc; + uint16_t buffer; + uint16_t sds_b = 1; + + dfacc = RZA_IO_RegRead_16(&USB200.D1FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC); + + if (dfacc == 2) + { + sds_b = 32; + } + else if (dfacc == 1) + { + sds_b = 16; + } + else + { + if (g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 2) + { + sds_b = 4; + } + else if (g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 1) + { + sds_b = 2; + } + else + { + sds_b = 1; + } + } + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE) + { + buffer = USB200.D1FIFOCTR; + dtln = (buffer & USB_FUNCTION_BITDTLN); + + if ((dtln % sds_b) != 0) + { + remain += (sds_b - (dtln % sds_b)); + } + g_usb0_function_PipeDataSize[pipe] = (g_usb0_function_data_count[pipe] - remain); + g_usb0_function_data_count[pipe] = remain; + } + } + + RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); +} + +/******************************************************************************* +* Function Name: usb0_function_dma_interrupt_d0fifo +* Description : This function is DMA interrupt handler entry. +* : Execute usb0_function_dmaint() after disabling DMA interrupt in this function. +* : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D0FIFO_DMA is +* : specified by dma->fifo. +* : Register this function as DMA complete interrupt. +* Arguments : uint32_t int_sense ; Interrupts detection mode +* : ; INTC_LEVEL_SENSITIVE : Level sense +* : ; INTC_EDGE_TRIGGER : Edge trigger +* Return Value : none +*******************************************************************************/ +void usb0_function_dma_interrupt_d0fifo (uint32_t int_sense) +{ + usb0_function_dmaint(USB_FUNCTION_D0FIFO); + g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY; +} + +/******************************************************************************* +* Function Name: usb0_function_dma_interrupt_d1fifo +* Description : This function is DMA interrupt handler entry. +* : Execute usb0_function_dmaint() after disabling DMA interrupt in this function. +* : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D1FIFO_DMA is +* : specified by dma->fifo. +* : Register this function as DMA complete interrupt. +* Arguments : uint32_t int_sense ; Interrupts detection mode +* : ; INTC_LEVEL_SENSITIVE : Level sense +* : ; INTC_EDGE_TRIGGER : Edge trigger +* Return Value : none +*******************************************************************************/ +void usb0_function_dma_interrupt_d1fifo (uint32_t int_sense) +{ + usb0_function_dmaint(USB_FUNCTION_D1FIFO); + g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY; +} + +/******************************************************************************* +* Function Name: usb0_function_dmaint +* Description : This function is DMA transfer end interrupt +* Arguments : uint16_t fifo ; fifo number +* : ; USB_FUNCTION_D0FIFO +* : ; USB_FUNCTION_D1FIFO +* Return Value : none +*******************************************************************************/ +static void usb0_function_dmaint (uint16_t fifo) +{ + uint16_t pipe; + + pipe = g_usb0_function_DmaPipe[fifo]; + + if (g_usb0_function_DmaInfo[fifo].dir == USB_FUNCTION_BUF2FIFO) + { + usb0_function_dmaint_buf2fifo(pipe); + } + else + { + usb0_function_dmaint_fifo2buf(pipe); + } +} + +/******************************************************************************* +* Function Name: usb0_function_dmaint_fifo2buf +* Description : Executes read completion from FIFO by DMAC. +* Arguments : uint16_t pipe : pipe number +* Return Value : none +*******************************************************************************/ +static void usb0_function_dmaint_fifo2buf (uint16_t pipe) +{ + uint32_t remain; + uint16_t useport; + + if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE) + { + useport = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + if (useport == USB_FUNCTION_D0FIFO_DMA) + { + remain = Userdef_USB_usb0_function_stop_dma0(); + usb0_function_dma_stop_d0(pipe, remain); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] == USB_FUNCTION_DMA_BUSYEND) + { + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + else + { + usb0_function_enable_brdy_int(pipe); + } + } + } + else + { + remain = Userdef_USB_usb0_function_stop_dma1(); + usb0_function_dma_stop_d1(pipe, remain); + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] == USB_FUNCTION_DMA_BUSYEND) + { + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + else + { + usb0_function_enable_brdy_int(pipe); + } + } + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_dmaint_buf2fifo +* Description : Executes write completion in FIFO by DMAC. +* Arguments : uint16_t pipe : pipe number +* Return Value : none +*******************************************************************************/ +static void usb0_function_dmaint_buf2fifo (uint16_t pipe) +{ + uint32_t remain; + uint16_t useport; + + useport = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + if (useport == USB_FUNCTION_D0FIFO_DMA) + { + remain = Userdef_USB_usb0_function_stop_dma0(); + usb0_function_dma_stop_d0(pipe, remain); + + if (g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] != 0) + { + RZA_IO_RegWrite_16(&USB200.D0FIFOCTR, + 1, + USB_DnFIFOCTR_BVAL_SHIFT, + USB_DnFIFOCTR_BVAL); + } + } + else + { + remain = Userdef_USB_usb0_function_stop_dma1(); + usb0_function_dma_stop_d1(pipe, remain); + + if (g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] != 0) + { + RZA_IO_RegWrite_16(&USB200.D1FIFOCTR, + 1, + USB_DnFIFOCTR_BVAL_SHIFT, + USB_DnFIFOCTR_BVAL); + } + } + + usb0_function_enable_bemp_int(pipe); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_intrn.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_intrn.c new file mode 100644 index 000000000..827efaed7 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_intrn.c @@ -0,0 +1,249 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_intrn.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb0_function_brdy_int +* Description : Executes BRDY interrupt(USB_FUNCTION_PIPE1-9). +* : According to the pipe that interrupt is generated in, +* : reads/writes buffer allocated in the pipe. +* : This function is executed in the BRDY interrupt handler. +* : This function clears BRDY interrupt status and BEMP interrupt +* : status. +* Arguments : uint16_t Status ; BRDYSTS Register Value +* : uint16_t Int_enbl ; BRDYENB Register Value +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_function_brdy_int (uint16_t status, uint16_t int_enb) +{ + uint32_t int_sense = 0; + uint16_t pipe; + uint16_t pipebit; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + pipebit = g_usb0_function_bit_set[pipe]; + + if ((status & pipebit) && (int_enb & pipebit)) + { + USB200.BRDYSTS = (uint16_t)~pipebit; + USB200.BEMPSTS = (uint16_t)~pipebit; + if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) + { + if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY) + { + usb0_function_dma_interrupt_d0fifo(int_sense); + } + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + usb0_function_read_dma(pipe); + usb0_function_disable_brdy_int(pipe); + } + else + { + USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + } + else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA) + { + if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY) + { + usb0_function_dma_interrupt_d1fifo(int_sense); + } + + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + usb0_function_read_dma(pipe); + usb0_function_disable_brdy_int(pipe); + } + else + { + USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + } + else + { + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) + { + usb0_function_read_buffer(pipe); + } + else + { + usb0_function_write_buffer(pipe); + } + } + } + } +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_nrdy_int +* Description : Executes NRDY interrupt(USB_FUNCTION_PIPE1-9). +* : Checks NRDY interrupt cause by PID. When the cause if STALL, +* : regards the pipe state as STALL and ends the processing. +* : Then the cause is not STALL, increments the error count to +* : communicate again. When the error count is 3, determines +* : the pipe state as DEVDRV_USBF_PIPE_NORES and ends the processing. +* : This function is executed in the NRDY interrupt handler. +* : This function clears NRDY interrupt status. +* Arguments : uint16_t status ; NRDYSTS Register Value +* : uint16_t int_enb ; NRDYENB Register Value +* Return Value : none +*******************************************************************************/ +void usb0_function_nrdy_int (uint16_t status, uint16_t int_enb) +{ + uint16_t pid; + uint16_t pipe; + uint16_t bitcheck; + + bitcheck = (uint16_t)(status & int_enb); + + USB200.NRDYSTS = (uint16_t)~status; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + if ((bitcheck&g_usb0_function_bit_set[pipe]) == g_usb0_function_bit_set[pipe]) + { + if (RZA_IO_RegRead_16(&USB200.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1) + { + if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT) + { + pid = usb0_function_get_pid(pipe); + if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) + { + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; + } + else + { + g_usb0_function_PipeIgnore[pipe]++; + if (g_usb0_function_PipeIgnore[pipe] == 3) + { + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES; + } + else + { + usb0_function_set_pid_buf(pipe); + } + } + } + } + else + { + /* USB Function */ + } + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_bemp_int +* Description : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9). +* Arguments : uint16_t status ; BEMPSTS Register Value +* : uint16_t int_enb ; BEMPENB Register Value +* Return Value : none +*******************************************************************************/ +void usb0_function_bemp_int (uint16_t status, uint16_t int_enb) +{ + uint16_t pid; + uint16_t pipe; + uint16_t bitcheck; + uint16_t inbuf; + + bitcheck = (uint16_t)(status & int_enb); + + USB200.BEMPSTS = (uint16_t)~status; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + if ((bitcheck&g_usb0_function_bit_set[pipe]) == g_usb0_function_bit_set[pipe]) + { + pid = usb0_function_get_pid(pipe); + + if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) + { + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; + } + else + { + inbuf = usb0_function_get_inbuf(pipe); + + if (inbuf == 0) + { + usb0_function_disable_bemp_int(pipe); + usb0_function_set_pid_nak(pipe); + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + } + } + } +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_lib.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_lib.c new file mode 100644 index 000000000..e3d318b98 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_lib.c @@ -0,0 +1,2026 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_lib.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb0_function_enable_brdy_int +* Description : Enables BRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling +* : BRDY. Enables BRDY interrupt in the pipe specified by the argument +* : in the disabled status. After enabling BRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_enable_brdy_int (uint16_t pipe) +{ + /* enable brdy interrupt */ + USB200.BRDYENB |= (uint16_t)g_usb0_function_bit_set[pipe]; +} + +/******************************************************************************* +* Function Name: usb0_function_disable_brdy_int +* Description : Disables BRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling +* : BRDY. Enables BRDY interrupt in the pipe specified by the argument +* : in the disabled status. After disabling BRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_disable_brdy_int (uint16_t pipe) +{ + /* disable brdy interrupt */ + USB200.BRDYENB &= (uint16_t)~(g_usb0_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb0_function_clear_brdy_sts +* Description : Clear BRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_clear_brdy_sts (uint16_t pipe) +{ + /* clear brdy status */ + USB200.BRDYSTS = (uint16_t)~(g_usb0_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb0_function_enable_bemp_int +* Description : Enables BEMP interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling +* : BEMP. Enables BEMP interrupt in the pipe specified by the argument +* : in the disabled status. After enabling BEMP, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_enable_bemp_int (uint16_t pipe) +{ + /* enable bemp interrupt */ + USB200.BEMPENB |= (uint16_t)g_usb0_function_bit_set[pipe]; +} + +/******************************************************************************* +* Function Name: usb0_function_disable_bemp_int +* Description : Disables BEMP interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling +* : BEMP. Enables BEMP interrupt in the pipe specified by the argument +* : in the disabled status. After enabling BEMP, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_disable_bemp_int (uint16_t pipe) +{ + /* disable bemp interrupt */ + USB200.BEMPENB &= (uint16_t)~(g_usb0_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb0_function_clear_bemp_sts +* Description : Clear BEMP interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_clear_bemp_sts (uint16_t pipe) +{ + /* clear bemp status */ + USB200.BEMPSTS = (uint16_t)~(g_usb0_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb0_function_enable_nrdy_int +* Description : Enables NRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling +* : NRDY. Enables NRDY interrupt in the pipe specified by the argument +* : in the disabled status. After enabling NRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_enable_nrdy_int (uint16_t pipe) +{ + /* enable nrdy interrupt */ + USB200.NRDYENB |= (uint16_t)g_usb0_function_bit_set[pipe]; +} + +/******************************************************************************* +* Function Name: usb0_function_disable_nrdy_int +* Description : Disables NRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling +* : NRDY. Disables NRDY interrupt in the pipe specified by the argument +* : in the disabled status. After disabling NRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_disable_nrdy_int (uint16_t pipe) +{ + /* disable nrdy interrupt */ + USB200.NRDYENB &= (uint16_t)~(g_usb0_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb0_function_clear_nrdy_sts +* Description : Clear NRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_clear_nrdy_sts (uint16_t pipe) +{ + /* clear nrdy status */ + USB200.NRDYSTS = (uint16_t)~(g_usb0_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb0_function_is_hispeed +* Description : Returns the result of USB reset hand shake (RHST) as +* : return value. +* Arguments : none +* Return Value : USB_FUNCTION_HIGH_SPEED ; Hi-Speed +* : USB_FUNCTION_FULL_SPEED ; Full-Speed +* : LOW_SPEED ; Low-Speed +* : USB_FUNCTION_NON_SPEED ; error +*******************************************************************************/ +uint16_t usb0_function_is_hispeed (void) +{ + uint16_t rhst; + uint16_t speed; + + rhst = RZA_IO_RegRead_16(&USB200.DVSTCTR0, USB_DVSTCTR0_RHST_SHIFT, USB_DVSTCTR0_RHST); + + if (rhst == USB_FUNCTION_HSMODE) + { + speed = USB_FUNCTION_HIGH_SPEED; + } + else if (rhst == USB_FUNCTION_FSMODE) + { + speed = USB_FUNCTION_FULL_SPEED; + } + else if (rhst == USB_FUNCTION_LSMODE) + { + speed = USB_FUNCTION_LOW_SPEED; + } + else + { + speed = USB_FUNCTION_NON_SPEED; + } + + return speed; +} + +/******************************************************************************* +* Function Name: usb0_function_is_hispeed_enable +* Description : Returns the USB High-Speed connection enabled status as +* : return value. +* Arguments : none +* Return Value : DEVDRV_USBF_YES : Hi-Speed Enable +* : DEVDRV_USBF_NO : Hi-Speed Disable +*******************************************************************************/ +uint16_t usb0_function_is_hispeed_enable (void) +{ + uint16_t ret; + + ret = DEVDRV_USBF_NO; + + if (RZA_IO_RegRead_16(&USB200.SYSCFG0, USB_SYSCFG_HSE_SHIFT, USB_SYSCFG_HSE) == 1) + { + ret = DEVDRV_USBF_YES; + } + + return ret; +} + +/******************************************************************************* +* Function Name: usb0_function_set_pid_buf +* Description : Enables communicaqtion in the pipe specified by the argument +* : (BUF). +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_set_pid_buf (uint16_t pipe) +{ + uint16_t pid; + + pid = usb0_function_get_pid(pipe); + + if (pid == DEVDRV_USBF_PID_STALL2) + { + usb0_function_set_pid_nak(pipe); + } + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + DEVDRV_USBF_PID_BUF, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_set_pid_nak +* Description : Disables communication (NAK) in the pipe specified by the argument. +* : When the pipe status was enabling communication (BUF) before +* : executing before executing this function, waits in the software +* : until the pipe becomes ready after setting disabled. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_set_pid_nak (uint16_t pipe) +{ + uint16_t pid; + uint16_t pbusy; + uint32_t loop; + + pid = usb0_function_get_pid(pipe); + + if (pid == DEVDRV_USBF_PID_STALL2) + { + usb0_function_set_pid_stall(pipe); + } + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + DEVDRV_USBF_PID_NAK, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } + + if (pid == DEVDRV_USBF_PID_BUF) + { + for (loop = 0; loop < 200; loop++) + { + switch (pipe) + { + case USB_FUNCTION_PIPE0: + pbusy = RZA_IO_RegRead_16(&USB200.DCPCTR, + USB_DCPCTR_PBUSY_SHIFT, + USB_DCPCTR_PBUSY); + break; + + case USB_FUNCTION_PIPE1: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE1CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE2: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE2CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE3: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE3CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE4: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE4CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE5: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE5CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE6: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE6CTR, + USB_PIPEnCTR_6_8_PBUSY_SHIFT, + USB_PIPEnCTR_6_8_PBUSY); + break; + + case USB_FUNCTION_PIPE7: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE7CTR, + USB_PIPEnCTR_6_8_PBUSY_SHIFT, + USB_PIPEnCTR_6_8_PBUSY); + break; + + case USB_FUNCTION_PIPE8: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE8CTR, + USB_PIPEnCTR_6_8_PBUSY_SHIFT, + USB_PIPEnCTR_6_8_PBUSY); + break; + + case USB_FUNCTION_PIPE9: + pbusy = RZA_IO_RegRead_16(&USB200.PIPE9CTR, + USB_PIPEnCTR_9_PBUSY_SHIFT, + USB_PIPEnCTR_9_PBUSY); + break; + + case USB_FUNCTION_PIPEA: + pbusy = RZA_IO_RegRead_16(&USB200.PIPEACTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEB: + pbusy = RZA_IO_RegRead_16(&USB200.PIPEBCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEC: + pbusy = RZA_IO_RegRead_16(&USB200.PIPECCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPED: + pbusy = RZA_IO_RegRead_16(&USB200.PIPEDCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEE: + pbusy = RZA_IO_RegRead_16(&USB200.PIPEECTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEF: + pbusy = RZA_IO_RegRead_16(&USB200.PIPEFCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + default: + pbusy = 1; + break; + } + + if (pbusy == 0) + { + break; + } + Userdef_USB_usb0_function_delay_500ns(); + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_set_pid_stall +* Description : Disables communication (STALL) in the pipe specified by the +* : argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_set_pid_stall (uint16_t pipe) +{ + uint16_t pid; + + pid = usb0_function_get_pid(pipe); + if (pid == DEVDRV_USBF_PID_BUF) + { + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + DEVDRV_USBF_PID_STALL2, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } + } + else + { + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + DEVDRV_USBF_PID_STALL, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } + } +} + +/******************************************************************************* +* Function Name: usb0_function_clear_pid_stall +* Description : Disables communication (NAK) in the pipe specified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_clear_pid_stall (uint16_t pipe) +{ + usb0_function_set_pid_nak(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_get_pid +* Description : Returns the pipe state specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : PID +*******************************************************************************/ +uint16_t usb0_function_get_pid (uint16_t pipe) +{ + uint16_t pid; + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + pid = RZA_IO_RegRead_16(&USB200.DCPCTR, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + pid = RZA_IO_RegRead_16(&USB200.PIPE1CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + pid = RZA_IO_RegRead_16(&USB200.PIPE2CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + pid = RZA_IO_RegRead_16(&USB200.PIPE3CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + pid = RZA_IO_RegRead_16(&USB200.PIPE4CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + pid = RZA_IO_RegRead_16(&USB200.PIPE5CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + pid = RZA_IO_RegRead_16(&USB200.PIPE6CTR, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + pid = RZA_IO_RegRead_16(&USB200.PIPE7CTR, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + pid = RZA_IO_RegRead_16(&USB200.PIPE8CTR, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + pid = RZA_IO_RegRead_16(&USB200.PIPE9CTR, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + pid = RZA_IO_RegRead_16(&USB200.PIPEACTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + pid = RZA_IO_RegRead_16(&USB200.PIPEBCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + pid = RZA_IO_RegRead_16(&USB200.PIPECCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + pid = RZA_IO_RegRead_16(&USB200.PIPEDCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + pid = RZA_IO_RegRead_16(&USB200.PIPEECTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + pid = RZA_IO_RegRead_16(&USB200.PIPEFCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + pid = 0; + break; + } + + return pid; +} + +/******************************************************************************* +* Function Name: usb0_function_set_csclr +* Description : CSPLIT status clear setting of sprit transaction in specified +* : pipe is performed. +* : When SQSET bit or SQCLR bit, and SQSET bit or SQCLR bit +* : in DCPCTR register are continuously changed (when the sequence +* : toggle bit of data PID is continuously changed over two or more pipes), +* : the access cycle with 120 ns and more than 5 cycle bus clock is necessary. +* : Do not set both SQCLR bit and SQSET bit to 1 at the same time. +* : In addition, both bits should be operated after PID is set to NAK. +* : However, when it is set to the isochronous transfer as the transfer type +* : (TYPE=11), writing in SQSET bit is disabled. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb0_function_set_csclr (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + 1, + USB_DCPCTR_CSCLR_SHIFT, + USB_DCPCTR_CSCLR); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_CSCLR_SHIFT, + USB_PIPEnCTR_6_8_CSCLR); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_CSCLR_SHIFT, + USB_PIPEnCTR_6_8_CSCLR); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_CSCLR_SHIFT, + USB_PIPEnCTR_6_8_CSCLR); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + 1, + USB_PIPEnCTR_9_CSCLR_SHIFT, + USB_PIPEnCTR_9_CSCLR); + break; + + default: + /* PIPEA-F have not CSCLR */ + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_set_sqclr +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA0. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_function_set_sqclr (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + 1, + USB_DCPCTR_SQCLR_SHIFT, + USB_DCPCTR_SQCLR); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_SQCLR_SHIFT, + USB_PIPEnCTR_6_8_SQCLR); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_SQCLR_SHIFT, + USB_PIPEnCTR_6_8_SQCLR); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_SQCLR_SHIFT, + USB_PIPEnCTR_6_8_SQCLR); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + 1, + USB_PIPEnCTR_9_SQCLR_SHIFT, + USB_PIPEnCTR_9_SQCLR); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_set_sqset +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA1. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb0_function_set_sqset (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB200.DCPCTR, + 1, + USB_DCPCTR_SQSET_SHIFT, + USB_DCPCTR_SQSET); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_SQSET_SHIFT, + USB_PIPEnCTR_6_8_SQSET); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_SQSET_SHIFT, + USB_PIPEnCTR_6_8_SQSET); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_SQSET_SHIFT, + USB_PIPEnCTR_6_8_SQSET); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + 1, + USB_PIPEnCTR_9_SQSET_SHIFT, + USB_PIPEnCTR_9_SQSET); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_get_sqmon +* Description : Toggle bit of specified pipe is obtained +* Arguments : uint16_t pipe ; Pipe number +* Return Value : sqmon +*******************************************************************************/ +uint16_t usb0_function_get_sqmon (uint16_t pipe) +{ + uint16_t sqmon; + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + sqmon = RZA_IO_RegRead_16(&USB200.DCPCTR, + USB_DCPCTR_SQMON_SHIFT, + USB_DCPCTR_SQMON); + break; + + case USB_FUNCTION_PIPE1: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE1CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE2: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE2CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE3: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE3CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE4: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE4CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE5: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE5CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE6: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE6CTR, + USB_PIPEnCTR_6_8_SQMON_SHIFT, + USB_PIPEnCTR_6_8_SQMON); + break; + + case USB_FUNCTION_PIPE7: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE7CTR, + USB_PIPEnCTR_6_8_SQMON_SHIFT, + USB_PIPEnCTR_6_8_SQMON); + break; + + case USB_FUNCTION_PIPE8: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE8CTR, + USB_PIPEnCTR_6_8_SQMON_SHIFT, + USB_PIPEnCTR_6_8_SQMON); + break; + + case USB_FUNCTION_PIPE9: + sqmon = RZA_IO_RegRead_16(&USB200.PIPE9CTR, + USB_PIPEnCTR_9_SQMON_SHIFT, + USB_PIPEnCTR_9_SQMON); + break; + + case USB_FUNCTION_PIPEA: + sqmon = RZA_IO_RegRead_16(&USB200.PIPEACTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEB: + sqmon = RZA_IO_RegRead_16(&USB200.PIPEBCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEC: + sqmon = RZA_IO_RegRead_16(&USB200.PIPECCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPED: + sqmon = RZA_IO_RegRead_16(&USB200.PIPEDCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEE: + sqmon = RZA_IO_RegRead_16(&USB200.PIPEECTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEF: + sqmon = RZA_IO_RegRead_16(&USB200.PIPEFCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + default: + sqmon = 0; + break; + } + + return sqmon; +} + +/******************************************************************************* +* Function Name: usb0_function_aclrm +* Description : The buffer of specified pipe is initialized +* Arguments : uint16_t pipe : Pipe +* Return Value : none +*******************************************************************************/ +void usb0_function_aclrm (uint16_t pipe) +{ + usb0_function_set_aclrm(pipe); + usb0_function_clr_aclrm(pipe); +} + +/******************************************************************************* +* Function Name: usb0_function_set_aclrm +* Description : The auto buffer clear mode of specified pipe is enabled +* Arguments : uint16_t pipe : Pipe +* Return Value : none +*******************************************************************************/ +void usb0_function_set_aclrm (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + 1, + USB_PIPEnCTR_9_ACLRM_SHIFT, + USB_PIPEnCTR_9_ACLRM); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_clr_aclrm +* Description : The auto buffer clear mode of specified pipe is enabled +* Arguments : uint16_t pipe : Pipe +* Return Value : none +*******************************************************************************/ +void usb0_function_clr_aclrm (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB200.PIPE1CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB200.PIPE2CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB200.PIPE3CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB200.PIPE4CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB200.PIPE5CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB200.PIPE6CTR, + 0, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB200.PIPE7CTR, + 0, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB200.PIPE8CTR, + 0, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB200.PIPE9CTR, + 0, + USB_PIPEnCTR_9_ACLRM_SHIFT, + USB_PIPEnCTR_9_ACLRM); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB200.PIPEACTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB200.PIPEBCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB200.PIPECCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB200.PIPEDCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB200.PIPEECTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB200.PIPEFCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_get_inbuf +* Description : Returns INBUFM of the pipe specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : inbuf +*******************************************************************************/ +uint16_t usb0_function_get_inbuf (uint16_t pipe) +{ + uint16_t inbuf; + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE1: + inbuf = RZA_IO_RegRead_16(&USB200.PIPE1CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE2: + inbuf = RZA_IO_RegRead_16(&USB200.PIPE2CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE3: + inbuf = RZA_IO_RegRead_16(&USB200.PIPE3CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE4: + inbuf = RZA_IO_RegRead_16(&USB200.PIPE4CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE5: + inbuf = RZA_IO_RegRead_16(&USB200.PIPE5CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE6: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE7: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE8: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE9: + inbuf = RZA_IO_RegRead_16(&USB200.PIPE9CTR, + USB_PIPEnCTR_9_INBUFM_SHIFT, + USB_PIPEnCTR_9_INBUFM); + break; + + case USB_FUNCTION_PIPEA: + inbuf = RZA_IO_RegRead_16(&USB200.PIPEACTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEB: + inbuf = RZA_IO_RegRead_16(&USB200.PIPEBCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEC: + inbuf = RZA_IO_RegRead_16(&USB200.PIPECCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPED: + inbuf = RZA_IO_RegRead_16(&USB200.PIPEDCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEE: + inbuf = RZA_IO_RegRead_16(&USB200.PIPEECTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEF: + inbuf = RZA_IO_RegRead_16(&USB200.PIPEFCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + default: + inbuf = 0; + break; + } + + return inbuf; +} + +/******************************************************************************* +* Function Name: usb0_function_setting_interrupt +* Description : Sets the USB module interrupt level. +* Arguments : uint8_t level ;interrupt level +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_function_setting_interrupt (uint8_t level) +{ + uint16_t d0fifo_dmaintid; + uint16_t d1fifo_dmaintid; + + R_INTC_RegistIntFunc(INTC_ID_USBI0, usb0_function_interrupt); + R_INTC_SetPriority(INTC_ID_USBI0, level); + R_INTC_Enable(INTC_ID_USBI0); + + d0fifo_dmaintid = Userdef_USB_usb0_function_d0fifo_dmaintid(); + + if (d0fifo_dmaintid != 0xFFFF) + { + R_INTC_RegistIntFunc(d0fifo_dmaintid, usb0_function_dma_interrupt_d0fifo); + R_INTC_SetPriority(d0fifo_dmaintid, level); + R_INTC_Enable(d0fifo_dmaintid); + } + + d1fifo_dmaintid = Userdef_USB_usb0_function_d1fifo_dmaintid(); + + if (d1fifo_dmaintid != 0xFFFF) + { + R_INTC_RegistIntFunc(d1fifo_dmaintid, usb0_function_dma_interrupt_d1fifo); + R_INTC_SetPriority(d1fifo_dmaintid, level); + R_INTC_Enable(d1fifo_dmaintid); + } +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_reset_module +* Description : Initializes the USB module. +* : Enables providing clock to the USB module. +* : Sets USB bus wait register. +* Arguments : uint16_t clockmode ; 48MHz ; USBFCLOCK_X1_48MHZ +* : ; 12MHz ; USBFCLOCK_EXTAL_12MHZ +* Return Value : none +*******************************************************************************/ +void usb0_function_reset_module (uint16_t clockmode) +{ + /* UPLLE bit is only USB0 */ + if (RZA_IO_RegRead_16(&USB200.SYSCFG0, + USB_SYSCFG_UPLLE_SHIFT, + USB_SYSCFG_UPLLE) == 1) + { + if ((USB200.SYSCFG0 & USB_FUNCTION_BITUCKSEL) != clockmode) + { + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + USB200.SYSCFG0 = 0; + USB200.SYSCFG0 = (USB_FUNCTION_BITUPLLE | clockmode); + Userdef_USB_usb0_function_delay_xms(1); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + } + else + { + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + Userdef_USB_usb0_function_delay_xms(1); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + } + } + else + { + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + USB200.SYSCFG0 = 0; + USB200.SYSCFG0 = (USB_FUNCTION_BITUPLLE | clockmode); + Userdef_USB_usb0_function_delay_xms(1); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + } + + USB200.BUSWAIT = (uint16_t)(USB_FUNCTION_BUSWAIT_05 & USB_FUNCTION_BITBWAIT); +} + +/******************************************************************************* +* Function Name: usb0_function_get_buf_size +* Description : Obtains pipe buffer size specified by the argument and +* : maximum packet size of the USB device in use. +* : When USB_FUNCTION_PIPE0 is specified by the argument, obtains the maximum +* : packet size of the USB device using the corresponding pipe. +* : For the case that USB_FUNCTION_PIPE0 is not assigned by the argument, when the +* : corresponding pipe is in continuous transfer mode, +* : obtains the buffer size allocated in the corresponcing pipe, +* : when incontinuous transfer, obtains maximum packet size. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : Maximum packet size or buffer size +*******************************************************************************/ +uint16_t usb0_function_get_buf_size (uint16_t pipe) +{ + uint16_t size; + uint16_t bufsize; + + if (pipe == USB_FUNCTION_PIPE0) + { + size = RZA_IO_RegRead_16(&USB200.DCPMAXP, + USB_DCPMAXP_MXPS_SHIFT, + USB_DCPMAXP_MXPS); + } + else + { + if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_CNTMD_SHIFT, USB_PIPECFG_CNTMD) == 1) + { + bufsize = RZA_IO_RegRead_16(&g_usb0_function_pipebuf[pipe], USB_PIPEBUF_BUFSIZE_SHIFT, USB_PIPEBUF_BUFSIZE); + size = (uint16_t)((bufsize + 1) * USB_FUNCTION_PIPExBUF); + } + else + { + size = RZA_IO_RegRead_16(&g_usb0_function_pipemaxp[pipe], USB_PIPEMAXP_MXPS_SHIFT, USB_PIPEMAXP_MXPS); + } + } + return size; +} + +/******************************************************************************* +* Function Name: usb0_function_get_mxps +* Description : Obtains maximum packet size of the USB device using the pipe +* : specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : Max Packet Size +*******************************************************************************/ +uint16_t usb0_function_get_mxps (uint16_t pipe) +{ + uint16_t size; + + if (pipe == USB_FUNCTION_PIPE0) + { + size = RZA_IO_RegRead_16(&USB200.DCPMAXP, + USB_DCPMAXP_MXPS_SHIFT, + USB_DCPMAXP_MXPS); + } + else + { + size = RZA_IO_RegRead_16(&g_usb0_function_pipemaxp[pipe], USB_PIPEMAXP_MXPS_SHIFT, USB_PIPEMAXP_MXPS); + } + return size; +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_api.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_api.c new file mode 100644 index 000000000..369b2bea6 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_api.c @@ -0,0 +1,441 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_api.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" +#include "dev_drv.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb0_api_function_init +* Description : Initializes the USB module in the USB function mode. +* Arguments : uint8_t int_level ; interruput level +* : uint16_t mode : Speed modes +* : : USB_FUCNTION_HIGH_SPEED: High-speed device +* : : USB_FUCNTION_FULL_SPEED: Full-speed device +* : uint16_t clockmode ; 48MHz ; USBFCLOCK_X1_48MHZ +* : ; 12MHz ; USBFCLOCK_EXTAL_12MHZ +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_api_function_init (uint8_t int_level, uint16_t mode, uint16_t clockmode) +{ + volatile uint8_t dummy_buf; + + CPG.STBCR7 &= 0xfd; /* The clock of USB0 modules is permitted */ + dummy_buf = CPG.STBCR7; /* (Dummy read) */ + + usb0_function_setting_interrupt(int_level); + + usb0_function_reset_module(clockmode); /* reset USB module with setting tranciever */ + /* and HSE=1 */ + + usb0_function_init_status(); /* clear variables */ + + usb0_function_InitModule(mode); /* select USB Function and Interrupt Enable */ + /* Detect USB Device to attach or detach */ +} +#endif + +/******************************************************************************* +* Function Name: usb0_api_function_IsConfigured +* Description : Checks if the USB device is configured to return the result as +* : the return value. +* Arguments : none +* Return Value : DEVDRV_USBF_YES : Configured & Configured Suspend +* : DEVDRV_USBF_NO : not Configured +*******************************************************************************/ +uint16_t usb0_api_function_IsConfigured (void) +{ + uint16_t dvst; + + dvst = usb0_function_GetDeviceState(); + + if ((dvst == USB_FUNCTION_DVST_CONFIGURED) || + (dvst == USB_FUNCTION_DVST_CONFIGURED_SUSPEND)) + { + return DEVDRV_USBF_YES; + } + + return DEVDRV_USBF_NO; +} + +/******************************************************************************* +* Function Name: usb0_function_GetDeviceState +* Description : Returns the state of USB device. +* Arguments : none +* Return Value : Device States +*******************************************************************************/ +uint16_t usb0_function_GetDeviceState (void) +{ + uint16_t dvsq; + uint16_t dvst; + + dvsq = USB200.INTSTS0; + switch(dvsq & USB_FUNCTION_BITDVSQ) + { + case USB_FUNCTION_DS_POWR: /* Power state *//* power-on */ + dvst = USB_FUNCTION_DVST_POWERED; + break; + + case USB_FUNCTION_DS_DFLT: /* Default state *//* bus-reset */ + dvst = USB_FUNCTION_DVST_DEFAULT; + break; + + case USB_FUNCTION_DS_ADDS: /* Address state */ + dvst = USB_FUNCTION_DVST_ADDRESS; + break; + + case USB_FUNCTION_DS_CNFG: /* Configured state */ + dvst = USB_FUNCTION_DVST_CONFIGURED; + break; + + case USB_FUNCTION_DS_SPD_CNFG: /* Configured Suspend state */ + dvst = USB_FUNCTION_DVST_CONFIGURED_SUSPEND; + break; + + case USB_FUNCTION_DS_SPD_POWR: /* Power Suspend state */ + case USB_FUNCTION_DS_SPD_DFLT: /* Default Suspend state */ + case USB_FUNCTION_DS_SPD_ADDR: /* Address Suspend state */ + dvst = USB_FUNCTION_DVST_SUSPEND; + break; + + default: /* error */ + dvst = USB_FUNCTION_DVST_SUSPEND; + break; + } + + return dvst; +} + +/******************************************************************************* +* Function Name: usb0_api_function_start_receive_transfer +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data data Address +* Return Value : none +*******************************************************************************/ +void usb0_api_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + usb0_function_start_receive_transfer(pipe, size, data); +} + +/******************************************************************************* +* Function Name: usb0_api_function_start_send_transfer +* Description : Starts the USB data communication using pipe specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data data Address +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb0_api_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t status; + + status = usb0_function_start_send_transfer(pipe, size, data); + + return status; +} + +/******************************************************************************* +* Function Name: usb0_api_function_check_pipe_status +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t *size ; Data Size +* Return Value : Pipe Status +*******************************************************************************/ +uint16_t usb0_api_function_check_pipe_status (uint16_t pipe, uint32_t * size) +{ + if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_DONE) + { + *size = g_usb0_function_PipeDataSize[pipe]; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_PIPE_DONE; + } + else if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_NORES) + { + *size = 0; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_PIPE_NORES; + } + else if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_STALL) + { + *size = 0; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_PIPE_STALL; + } + else if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_FIFOERROR) + { + *size = 0; + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_FIFOERROR; + } + else + { + /* Do Nothing */ + } + + return g_usb0_function_pipe_status[pipe]; +} + +/******************************************************************************* +* Function Name: usb0_api_function_clear_pipe_status +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : Pipe Status +*******************************************************************************/ +void usb0_api_function_clear_pipe_status (uint16_t pipe) +{ + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usb0_function_PipeDataSize[pipe] = 0; +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_pid_buf +* Description : Enables communicaqtion in the pipe specified by the argument +* : (BUF). +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_pid_buf (uint16_t pipe) +{ + usb0_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_pid_nak +* Description : Disables communication (NAK) in the pipe specified by the argument. +* : When the pipe status was enabling communication (BUF) before +* : executing before executing this function, waits in the software +* : until the pipe becomes ready after setting disabled. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_pid_nak (uint16_t pipe) +{ + usb0_function_set_pid_nak(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_pid_stall +* Description : Disables communication (STALL) in the pipe specified by the +* : argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_pid_stall (uint16_t pipe) +{ + usb0_function_set_pid_stall(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_clear_pid_stall +* Description : Disables communication (NAK) in the pipe specified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_clear_pid_stall (uint16_t pipe) +{ + usb0_function_clear_pid_stall(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_get_pid +* Description : Returns the pipe state specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : PID +*******************************************************************************/ +uint16_t usb0_api_function_get_pid (uint16_t pipe) +{ + uint16_t pid; + + pid = usb0_function_get_pid(pipe); + + return pid; +} + +/******************************************************************************* +* Function Name: usb0_api_function_check_stall +* Description : +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : PID +*******************************************************************************/ +int32_t usb0_api_function_check_stall (uint16_t pipe) +{ + uint16_t pid; + + pid = usb0_function_get_pid(pipe); + + if ((pid & DEVDRV_USBF_PID_STALL) == DEVDRV_USBF_PID_STALL) + { + return DEVDRV_USBF_STALL; + } + + return DEVDRV_SUCCESS; +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_sqclr +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA0. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_sqclr (uint16_t pipe) +{ + usb0_function_set_sqclr(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_sqset +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA1. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_sqset (uint16_t pipe) +{ + usb0_function_set_sqset(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_csclr +* Description : CSPLIT status clear setting of sprit transaction in specified +* : pipe is performed. +* : When SQSET bit or SQCLR bit, and SQSET bit or SQCLR bit +* : in DCPCTR register are continuously changed (when the sequence +* : toggle bit of data PID is continuously changed over two or more pipes), +* : the access cycle with 120 ns and more than 5 cycle bus clock is necessary. +* : Do not set both SQCLR bit and SQSET bit to 1 at the same time. +* : In addition, both bits should be operated after PID is set to NAK. +* : However, when it is set to the isochronous transfer as the transfer type +* : (TYPE=11), writing in SQSET bit is disabled. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_csclr (uint16_t pipe) +{ + usb0_function_set_csclr(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_set_curpipe +* Description : Allocates FIF0 specifed by the argument in the pipe assigned +* : by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* Return Value : none +*******************************************************************************/ +void usb0_api_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw) +{ + usb0_function_set_curpipe(pipe, fifosel, isel, mbw); +} + +/******************************************************************************* +* Function Name: usb0_api_function_clear_brdy_sts +* Description : Clear BRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_clear_brdy_sts (uint16_t pipe) +{ + usb0_function_clear_brdy_sts(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_clear_bemp_sts +* Description : Clear BEMP interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_clear_bemp_sts (uint16_t pipe) +{ + usb0_function_clear_bemp_sts(pipe); +} + +/******************************************************************************* +* Function Name: usb0_api_function_clear_nrdy_sts +* Description : Clear NRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb0_api_function_clear_nrdy_sts (uint16_t pipe) +{ + usb0_function_clear_nrdy_sts(pipe); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_controlrw.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_controlrw.c new file mode 100644 index 000000000..0a9121ab8 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_controlrw.c @@ -0,0 +1,142 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_controlrw.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb0_api_function_CtrlReadStart +* Description : Executes the USB control read transfer. +* : USB host controller <- USB device +* Arguments : uint16_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : DEVDRV_USBF_WRITEEND ; End of data write +* : DEVDRV_USBF_WRITESHRT ; End of short data write +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_FIFOERROR ; FIFO access error +*******************************************************************************/ +uint16_t usb0_api_function_CtrlReadStart (uint32_t size, uint8_t * data) +{ + uint16_t status; + uint16_t mbw; + + usb0_function_set_pid_nak(USB_FUNCTION_PIPE0); + + g_usb0_function_data_count[USB_FUNCTION_PIPE0] = size; + g_usb0_function_data_pointer[USB_FUNCTION_PIPE0] = data; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[USB_FUNCTION_PIPE0], + (uint32_t)g_usb0_function_data_pointer[USB_FUNCTION_PIPE0]); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw); + USB200.CFIFOCTR = USB_FUNCTION_BITBCLR; + + status = usb0_function_write_buffer_c(USB_FUNCTION_PIPE0); + + /* Peripheral Control sequence */ + switch (status) + { + case DEVDRV_USBF_WRITESHRT: /* End of data write */ + case DEVDRV_USBF_WRITEEND: /* End of data write (not null) */ + case DEVDRV_USBF_WRITING: /* Continue of data write */ + usb0_function_enable_bemp_int(USB_FUNCTION_PIPE0); /* Enable Empty Interrupt */ + usb0_function_set_pid_buf(USB_FUNCTION_PIPE0); /* Set BUF */ + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access error */ + break; + + default: + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb0_api_function_CtrlWriteStart +* Description : Executes the USB control write transfer. +* : USB host controller -> USB device +* Arguments : uint16_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +void usb0_api_function_CtrlWriteStart (uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb0_function_set_pid_nak(USB_FUNCTION_PIPE0); + + g_usb0_function_data_count[USB_FUNCTION_PIPE0] = size; + g_usb0_function_data_pointer[USB_FUNCTION_PIPE0] = data; + + mbw = usb0_function_get_mbw(g_usb0_function_data_count[USB_FUNCTION_PIPE0], + (uint32_t)g_usb0_function_data_pointer[USB_FUNCTION_PIPE0]); + usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw); + USB200.CFIFOCTR = USB_FUNCTION_BITBCLR; + + usb0_function_enable_brdy_int(USB_FUNCTION_PIPE0); + usb0_function_set_pid_buf(USB_FUNCTION_PIPE0); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_global.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_global.c new file mode 100644 index 000000000..5f1ff018f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_global.c @@ -0,0 +1,144 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_global.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +const uint16_t g_usb0_function_bit_set[16] = +{ + 0x0001, 0x0002, 0x0004, 0x0008, + 0x0010, 0x0020, 0x0040, 0x0080, + 0x0100, 0x0200, 0x0400, 0x0800, + 0x1000, 0x2000, 0x4000, 0x8000 +}; + +uint32_t g_usb0_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint8_t * g_usb0_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1]; + +uint16_t g_usb0_function_PipeIgnore[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb0_function_PipeTbl[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb0_function_pipe_status[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint32_t g_usb0_function_PipeDataSize[USB_FUNCTION_MAX_PIPE_NO + 1]; + +USB_FUNCTION_DMA_t g_usb0_function_DmaInfo[2]; +uint16_t g_usb0_function_DmaPipe[2]; +uint16_t g_usb0_function_DmaBval[2]; +uint16_t g_usb0_function_DmaStatus[2]; + +uint16_t g_usb0_function_CtrZeroLengthFlag; + +//uint16_t g_usb0_function_ConfigNum; +//uint16_t g_usb0_function_Alternate[USB_FUNCTION_ALT_NO]; +//uint16_t g_usb0_function_RemoteWakeupFlag; +uint16_t g_usb0_function_TestModeFlag; +uint16_t g_usb0_function_TestModeSelectors; + +//uint16_t g_usb0_function_ReqType; +//uint16_t g_usb0_function_ReqTypeType; +//uint16_t g_usb0_function_ReqTypeRecip; +//uint16_t g_usb0_function_ReqRequest; +//uint16_t g_usb0_function_ReqValue; +//uint16_t g_usb0_function_ReqIndex; +//uint16_t g_usb0_function_ReqLength; + +//uint16_t g_usb0_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1]; + +uint16_t g_usb0_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb0_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb0_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb0_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1]; + + +/******************************************************************************* +* Function Name: usb0_function_init_status +* Description : Initialization USB Sample Driver Variable. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb0_function_init_status (void) +{ + uint16_t pipe; + + //g_usb0_function_ConfigNum = 0; + //g_usb0_function_RemoteWakeupFlag = DEVDRV_USBF_OFF; + g_usb0_function_TestModeFlag = DEVDRV_USBF_OFF; + g_usb0_function_CtrZeroLengthFlag = 0; + +#if 0 + usb0_function_clear_alt(); +#endif + + for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe) + { + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usb0_function_PipeDataSize[pipe] = 0; + g_usb0_function_data_count[pipe] = 0; + + /* pipe configuration in usb0_function_ResetEP() */ + g_usb0_function_pipecfg[pipe] = 0; + g_usb0_function_pipebuf[pipe] = 0; + g_usb0_function_pipemaxp[pipe] = 0; + g_usb0_function_pipeperi[pipe] = 0; + } +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sig.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sig.c new file mode 100644 index 000000000..66949dee6 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sig.c @@ -0,0 +1,330 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_sig.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +static void usb0_function_EnableINTModule(void); + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb0_function_InitModule +* Description : Initializes the USB module in the USB function mode. +* Arguments : uint16_t mode ; USB_FUNCTION_HIGH_SPEED ; Hi-Speed Mode +* : ; other ; Full-speed Mode +* Return Value : none +*******************************************************************************/ +void usb0_function_InitModule (uint16_t mode) +{ + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 0, + USB_SYSCFG_DCFM_SHIFT, + USB_SYSCFG_DCFM); /* USB function */ + + /* USB module operation enabled */ + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 1, + USB_SYSCFG_USBE_SHIFT, + USB_SYSCFG_USBE); + + if (mode == USB_FUNCTION_HIGH_SPEED) + { + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 1, + USB_SYSCFG_HSE_SHIFT, + USB_SYSCFG_HSE); /* Hi-Speed Mode */ + } + else + { + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 0, + USB_SYSCFG_HSE_SHIFT, + USB_SYSCFG_HSE); + } + + /* for power-on */ + if (usb0_function_CheckVBUStaus() == DEVDRV_USBF_ON) + { + usb0_function_EnableINTModule(); /* Interrupt Enable */ + usb0_function_USB_FUNCTION_Attach(); /* pull-up D+ and open D- */ + } + else + { + usb0_function_USB_FUNCTION_Detach(); /* USB Detach */ + /* with Interrupt Enable */ + } +} + +/******************************************************************************* +* Function Name: usb0_function_CheckVBUStaus +* Description : Checks the USB-VBUS state to returns the connection state to +* : the USB host. +* Arguments : none +* Return Value : DEVDRV_USBF_ON : VBUS ON +* : DEVDRV_USBF_OFF : VBUS OFF +*******************************************************************************/ +uint16_t usb0_function_CheckVBUStaus (void) +{ + uint16_t buf1; + uint16_t buf2; + uint16_t buf3; + + /* monitor VBUS pins */ + do + { + buf1 = RZA_IO_RegRead_16(&USB200.INTSTS0, + USB_INTSTS0_VBSTS_SHIFT, + USB_INTSTS0_VBSTS); + Userdef_USB_usb0_function_delay_10us(1); + buf2 = RZA_IO_RegRead_16(&USB200.INTSTS0, + USB_INTSTS0_VBSTS_SHIFT, + USB_INTSTS0_VBSTS); + Userdef_USB_usb0_function_delay_10us(1); + buf3 = RZA_IO_RegRead_16(&USB200.INTSTS0, + USB_INTSTS0_VBSTS_SHIFT, + USB_INTSTS0_VBSTS); + } while ((buf1 != buf2) || (buf2 != buf3)); + + if (buf1 == DEVDRV_USBF_OFF) + { + return DEVDRV_USBF_OFF; /* detach */ + } + + return DEVDRV_USBF_ON; /* attach */ +} + +/******************************************************************************* +* Function Name: usb0_function_USB_FUNCTION_Attach +* Description : Connects to the USB host controller. +* : This function pulls up D+. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb0_function_USB_FUNCTION_Attach (void) +{ + Userdef_USB_usb0_function_attach(); + + Userdef_USB_usb0_function_delay_xms(10); + + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 1, + USB_SYSCFG_DPRPU_SHIFT, + USB_SYSCFG_DPRPU); /* Pull-up D+ and open D- */ +} + +/******************************************************************************* +* Function Name: usb0_function_USB_FUNCTION_Detach +* Description : Disconnects from the USB host controller. +* : This function opens D+/D-. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb0_function_USB_FUNCTION_Detach (void) +{ + uint16_t pipe; + + Userdef_USB_usb0_function_detach(); + + for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe) + { + if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_IDLE) + { + usb0_function_stop_transfer(pipe); + } + } + + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 0, + USB_SYSCFG_DPRPU_SHIFT, + USB_SYSCFG_DPRPU); /* open D+ and D- */ + + /* Detach Recovery */ + Userdef_USB_usb0_function_delay_500ns(); /* need 1us=500ns * 2 wait */ + Userdef_USB_usb0_function_delay_500ns(); + + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 1, + USB_SYSCFG_DCFM_SHIFT, + USB_SYSCFG_DCFM); + Userdef_USB_usb0_function_delay_500ns(); /* need 100ns wait but 500ns S/W wait */ + + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 0, + USB_SYSCFG_DCFM_SHIFT, + USB_SYSCFG_DCFM); + + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 0, + USB_SYSCFG_USBE_SHIFT, + USB_SYSCFG_USBE); /* soft reset module */ + Userdef_USB_usb0_function_delay_500ns(); + + RZA_IO_RegWrite_16(&USB200.SYSCFG0, + 1, + USB_SYSCFG_USBE_SHIFT, + USB_SYSCFG_USBE); + + usb0_function_EnableINTModule(); /* Interrupt Enable */ +} + +/******************************************************************************* +* Function Name: usb0_function_USB_FUNCTION_BusReset +* Description : This function is executed when the USB device is transitioned +* : to POWERD_STATE. Sets the device descriptor according to the +* : connection speed determined by the USB reset hand shake. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 /*The USBHAL in mbed does not need this function*/ +void usb0_function_USB_FUNCTION_BusReset (void) +{ + usb0_function_init_status(); /* memory clear */ + + if (usb0_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED) + { + usb0_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED); /* Device Descriptor reset */ + } + else + { + usb0_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED); /* Device Descriptor reset */ + } + + usb0_function_ResetDCP(); /* Default Control PIPE reset */ +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_USB_FUNCTION_Resume +* Description : This function is executed when the USB device detects a resume +* : signal. +* : The USB sample driver does not operate for this function. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 /*The USBHAL in mbed does not need this function*/ +void usb0_function_USB_FUNCTION_Resume (void) +{ + /* NOP */ +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_USB_FUNCTION_Suspend +* Description : This function is executed when the USB device detects a suspend +* : signal. +* : The USB sample driver does not operate for this function. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 /*The USBHAL in mbed does not need this function*/ +void usb0_function_USB_FUNCTION_Suspend (void) +{ + /* NOP */ +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_USB_FUNCTION_TestMode +* Description : This function is executed when the USB device is transitioned U +* : to TEST_MODE by the USB standard request. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb0_function_USB_FUNCTION_TestMode (void) +{ + switch (g_usb0_function_TestModeSelectors & USB_FUNCTION_FUNCTION_TEST_SELECT) + { + case USB_FUNCTION_FUNCTION_TEST_J: + case USB_FUNCTION_FUNCTION_TEST_K: + case USB_FUNCTION_FUNCTION_TEST_SE0_NAK: + case USB_FUNCTION_FUNCTION_TEST_PACKET: + RZA_IO_RegWrite_16(&USB200.TESTMODE, + (g_usb0_function_TestModeSelectors >> 8), + USB_TESTMODE_UTST_SHIFT, + USB_TESTMODE_UTST); + break; + + case USB_FUNCTION_FUNCTION_TEST_FORCE_ENABLE: + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb0_function_EnableINTModule +* Description : Enables USB interrupt. +* Arguments : none +* Return Value : none +*******************************************************************************/ +static void usb0_function_EnableINTModule (void) +{ + uint16_t buf; + + buf = USB200.INTENB0; + buf |= (USB_FUNCTION_BITVBSE | USB_FUNCTION_BITDVSE | USB_FUNCTION_BITCTRE | + USB_FUNCTION_BITBEMPE | USB_FUNCTION_BITNRDYE | USB_FUNCTION_BITBRDYE); + USB200.INTENB0 = buf; + + usb0_function_enable_bemp_int(USB_FUNCTION_PIPE0); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sub.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sub.c new file mode 100644 index 000000000..df7fbf5bb --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sub.c @@ -0,0 +1,453 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_sub.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb0_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ +#if 0 +extern const uint16_t *g_usb0_function_EndPntPtr[]; +extern uint8_t g_usb0_function_DeviceDescriptor[]; +extern uint8_t *g_usb0_function_ConfigurationPtr[]; +#endif + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb0_function_ResetDCP +* Description : Initializes the default control pipe(DCP). +* Outline : Reset default control pipe +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb0_function_ResetDCP (void) +{ + USB200.DCPCFG = 0; +#if 0 + USB200.DCPMAXP = g_usb0_function_DeviceDescriptor[7]; +#else + USB200.DCPMAXP = 64; +#endif + + USB200.CFIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + USB200.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + USB200.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); +} + +/******************************************************************************* +* Function Name: usb0_function_ResetEP +* Description : Initializes the end point. +* Arguments : uint16_t num ; Configuration Number +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_function_ResetEP (uint16_t num) +{ + uint16_t pipe; + uint16_t ep; + uint16_t index; + uint16_t buf; + uint16_t * tbl; + + tbl = (uint16_t *)(g_usb0_function_EndPntPtr[num - 1]); + + for (ep = 1; ep <= USB_FUNCTION_MAX_EP_NO; ++ep) + { + if (g_usb0_function_EPTableIndex[ep] != USB_FUNCTION_EP_ERROR) + { + index = (uint16_t)(USB_FUNCTION_EPTABLE_LENGTH * g_usb0_function_EPTableIndex[ep]); + pipe = (uint16_t)(tbl[index + 0] & USB_FUNCTION_BITCURPIPE); + + g_usb0_function_PipeTbl[pipe] = (uint16_t)( ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) << 3) | + ep | + (tbl[index + 0] & USB_FUNCTION_FIFO_USE) ); + + if ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) == USB_FUNCTION_DIR_P_OUT) + { + tbl[index + 1] |= USB_FUNCTION_SHTNAKON; +#ifdef __USB_DMA_BFRE_ENABLE__ + /* this routine cannnot be perfomred if read operation is executed in buffer size */ + if (((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) || + ((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA)) + { + tbl[index + 1] |= USB_FUNCTION_BFREON; + } +#endif + } + + /* Interrupt Disable */ + buf = USB200.BRDYENB; + buf &= (uint16_t)~g_usb0_function_bit_set[pipe]; + USB200.BRDYENB = buf; + buf = USB200.NRDYENB; + buf &= (uint16_t)~g_usb0_function_bit_set[pipe]; + USB200.NRDYENB = buf; + buf = USB200.BEMPENB; + buf &= (uint16_t)~g_usb0_function_bit_set[pipe]; + USB200.BEMPENB = buf; + + usb0_function_set_pid_nak(pipe); + + /* CurrentPIPE Clear */ + if (RZA_IO_RegRead_16(&USB200.CFIFOSEL, + USB_CFIFOSEL_CURPIPE_SHIFT, + USB_CFIFOSEL_CURPIPE) == pipe) + { + RZA_IO_RegWrite_16(&USB200.CFIFOSEL, + 0, + USB_CFIFOSEL_CURPIPE_SHIFT, + USB_CFIFOSEL_CURPIPE); + } + + if (RZA_IO_RegRead_16(&USB200.D0FIFOSEL, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE) == pipe) + { + RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, + 0, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE); + } + + if (RZA_IO_RegRead_16(&USB200.D1FIFOSEL, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE) == pipe) + { + RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, + 0, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE); + } + + /* PIPE Configuration */ + USB200.PIPESEL = pipe; + USB200.PIPECFG = tbl[index + 1]; + USB200.PIPEBUF = tbl[index + 2]; + USB200.PIPEMAXP = tbl[index + 3]; + USB200.PIPEPERI = tbl[index + 4]; + + g_usb0_function_pipecfg[pipe] = tbl[index + 1]; + g_usb0_function_pipebuf[pipe] = tbl[index + 2]; + g_usb0_function_pipemaxp[pipe] = tbl[index + 3]; + g_usb0_function_pipeperi[pipe] = tbl[index + 4]; + + /* Buffer Clear */ + usb0_function_set_sqclr(pipe); + usb0_function_aclrm(pipe); + + /* init Global */ + g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usb0_function_PipeDataSize[pipe] = 0; + } + } +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_EpToPipe +* Description : Returns the pipe which end point specified by the argument is +* : allocated to. +* Arguments : uint16_t ep ; Direction + Endpoint Number +* Return Value : USB_FUNCTION_EP_ERROR : Error +* : Others : Pipe Number +*******************************************************************************/ +uint16_t usb0_function_EpToPipe (uint16_t ep) +{ + uint16_t pipe; + + for (pipe = 1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + if ((g_usb0_function_PipeTbl[pipe] & 0x00ff) == ep) + { + return pipe; + } + } + + return USB_FUNCTION_EP_ERROR; +} + +/******************************************************************************* +* Function Name: usb0_function_InitEPTable +* Description : Sets the end point by the Alternate setting value of the +* : configuration number and the interface number specified by the +* : argument. +* Arguments : uint16_t Con_Num ; Configuration Number +* : uint16_t Int_Num ; Interface Number +* : uint16_t Alt_Num ; Alternate Setting +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_function_InitEPTable (uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num) +{ + uint8_t * ptr; + uint16_t point_interface; + uint16_t point_endpoint; + uint16_t length; + uint16_t start; + uint16_t numbers; + uint16_t endpoint; + + ptr = (uint8_t *)g_usb0_function_ConfigurationPtr[Con_Num - 1]; + point_interface = *ptr; + length = (uint16_t)((uint16_t)*(ptr + 3) << 8 | (uint16_t)*(ptr + 2)); + ptr += *ptr; + start = 0; + numbers = 0; + point_endpoint = 0; + + for (; point_interface < length;) + { + switch (*(ptr + 1)) /* Descriptor Type ? */ + { + case USB_FUNCTION_DT_INTERFACE: /* Interface */ + if ((*(ptr + 2) == Int_Num) && (*(ptr + 3) == Alt_Num)) + { + numbers = *(ptr + 4); + } + else + { + start += *(ptr + 4); + } + point_interface += *ptr; + ptr += *ptr; + break; + + case USB_FUNCTION_DT_ENDPOINT: /* Endpoint */ + if (point_endpoint < numbers) + { + endpoint = (uint16_t)(*(ptr + 2) & 0x0f); + g_usb0_function_EPTableIndex[endpoint] = (uint16_t)(start + point_endpoint); + ++point_endpoint; + } + point_interface += *ptr; + ptr += *ptr; + break; + + case USB_FUNCTION_DT_DEVICE: /* Device */ + case USB_FUNCTION_DT_CONFIGURATION: /* Configuration */ + case USB_FUNCTION_DT_STRING: /* String */ + default: /* Class, Vendor, else */ + point_interface += *ptr; + ptr += *ptr; + break; + } + } +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_GetConfigNum +* Description : Returns the number of configuration referring to the number of +* : configuration described in the device descriptor. +* Arguments : none +* Return Value : Number of possible configurations (bNumConfigurations). +*******************************************************************************/ +#if 0 +uint16_t usb0_function_GetConfigNum (void) +{ + return (uint16_t)g_usb0_function_DeviceDescriptor[17]; +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_GetInterfaceNum +* Description : Returns the number of interface referring to the number of +* : interface described in the configuration descriptor. +* Arguments : uint16_t num ; Configuration Number +* Return Value : Number of this interface (bNumInterfaces). +*******************************************************************************/ +#if 0 +uint16_t usb0_function_GetInterfaceNum (uint16_t num) +{ + return (uint16_t)(*(g_usb0_function_ConfigurationPtr[num - 1] + 4)); +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_GetAltNum +* Description : Returns the Alternate setting value of the configuration number +* : and the interface number specified by the argument. +* Arguments : uint16_t Con_Num ; Configuration Number +* : uint16_t Int_Num ; Interface Number +* Return Value : Value used to select this alternate setting(bAlternateSetting). +*******************************************************************************/ +#if 0 +uint16_t usb0_function_GetAltNum (uint16_t Con_Num, uint16_t Int_Num) +{ + uint8_t * ptr; + uint16_t point; + uint16_t alt_num = 0; + uint16_t length; + + ptr = (uint8_t *)(g_usb0_function_ConfigurationPtr[Con_Num - 1]); + point = ptr[0]; + ptr += ptr[0]; /* InterfaceDescriptor[0] */ + length = (uint16_t)(*(g_usb0_function_ConfigurationPtr[Con_Num - 1] + 2)); + length |= (uint16_t)((uint16_t)(*(g_usb0_function_ConfigurationPtr[Con_Num - 1] + 3)) << 8); + + for (; point < length;) /* Search Descriptor Table size */ + { + switch (ptr[1]) /* Descriptor Type ? */ + { + case USB_FUNCTION_DT_INTERFACE: /* Interface */ + if (Int_Num == ptr[2]) + { + alt_num = (uint16_t)ptr[3]; /* Alternate Number count */ + } + point += ptr[0]; + ptr += ptr[0]; + break; + + case USB_FUNCTION_DT_DEVICE: /* Device */ + case USB_FUNCTION_DT_CONFIGURATION: /* Configuration */ + case USB_FUNCTION_DT_STRING: /* String */ + case USB_FUNCTION_DT_ENDPOINT: /* Endpoint */ + default: /* Class, Vendor, else */ + point += ptr[0]; + ptr += ptr[0]; + break; + } + } + return alt_num; +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_CheckRemoteWakeup +* Description : Returns the result of the remote wake up function is supported +* : or not referring to the configuration descriptor. +* Arguments : none +* Return Value : DEVDRV_USBF_ON : Support Remote Wakeup +* : DEVDRV_USBF_OFF : not Support Remote Wakeup +*******************************************************************************/ +#if 0 +uint16_t usb0_function_CheckRemoteWakeup (void) +{ + uint8_t atr; + + if (g_usb0_function_ConfigNum == 0) + { + return DEVDRV_USBF_OFF; + } + + atr = *(g_usb0_function_ConfigurationPtr[g_usb0_function_ConfigNum - 1] + 7); + + if (atr & USB_FUNCTION_CF_RWUP) + { + return DEVDRV_USBF_ON; + } + + return DEVDRV_USBF_OFF; +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_clear_alt +* Description : Initializes the Alternate setting area. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_function_clear_alt (void) +{ + int i; + + for (i = 0; i < USB_FUNCTION_ALT_NO; ++i) + { + g_usb0_function_Alternate[i] = 0; /* Alternate */ + } +} +#endif + +/******************************************************************************* +* Function Name: usb0_function_clear_pipe_tbl +* Description : Initializes pipe definition table. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb0_function_clear_pipe_tbl (void) +{ + int pipe; + + for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe) + { + g_usb0_function_PipeTbl[pipe] = 0; + } +} + +/******************************************************************************* +* Function Name: usb0_function_clear_ep_table_index +* Description : Initializes the end point table index. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 +void usb0_function_clear_ep_table_index (void) +{ + int ep; + + for (ep = 0; ep <= USB_FUNCTION_MAX_EP_NO; ++ep) + { + g_usb0_function_EPTableIndex[ep] = USB_FUNCTION_EP_ERROR; + } +} +#endif + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_dmacdrv.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_dmacdrv.c new file mode 100644 index 000000000..5b46b68ee --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_dmacdrv.c @@ -0,0 +1,698 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_dmacdrv.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include <stdio.h> +#include "r_typedefs.h" +#include "iodefine.h" +#include "rza_io_regrw.h" +#include "usb0_function_dmacdrv.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +#define DMAC_INDEFINE (255) /* Macro definition when REQD bit is not used */ + +/* ==== Request setting information for on-chip peripheral module ==== */ +typedef enum dmac_peri_req_reg_type +{ + DMAC_REQ_MID, + DMAC_REQ_RID, + DMAC_REQ_AM, + DMAC_REQ_LVL, + DMAC_REQ_REQD +} dmac_peri_req_reg_type_t; + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +/* ==== Prototype declaration ==== */ + +/* ==== Global variable ==== */ +/* On-chip peripheral module request setting table */ +static const uint8_t usb0_function_dmac_peri_req_init_table[8][5] = +{ + /* MID,RID,AM,LVL,REQD */ + {32, 3, 2, 1, 1}, /* USB_0 channel 0 transmit FIFO empty */ + {32, 3, 2, 1, 0}, /* USB_0 channel 0 receive FIFO full */ + {33, 3, 2, 1, 1}, /* USB_0 channel 1 transmit FIFO empty */ + {33, 3, 2, 1, 0}, /* USB_0 channel 1 receive FIFO full */ + {34, 3, 2, 1, 1}, /* USB_1 channel 0 transmit FIFO empty */ + {34, 3, 2, 1, 0}, /* USB_1 channel 0 receive FIFO full */ + {35, 3, 2, 1, 1}, /* USB_1 channel 1 transmit FIFO empty */ + {35, 3, 2, 1, 0}, /* USB_1 channel 1 receive FIFO full */ +}; + + +/******************************************************************************* +* Function Name: usb0_function_DMAC1_PeriReqInit +* Description : Sets the register mode for DMA mode and the on-chip peripheral +* : module request for transfer request for DMAC channel 1. +* : Executes DMAC initial setting using the DMA information +* : specified by the argument *trans_info and the enabled/disabled +* : continuous transfer specified by the argument continuation. +* : Registers DMAC channel 1 interrupt handler function and sets +* : the interrupt priority level. Then enables transfer completion +* : interrupt. +* Arguments : dmac_transinfo_t *trans_info : Setting information to DMAC register +* : uint32_t dmamode : DMA mode (only for DMAC_MODE_REGISTER) +* : uint32_t continuation : Set continuous transfer to be valid +* : after DMA transfer has been completed +* : DMAC_SAMPLE_CONTINUATION : Execute continuous transfer +* : DMAC_SAMPLE_SINGLE : Do not execute continuous transfer +* : uint32_t request_factor : Factor for on-chip peripheral module request +* : DMAC_REQ_OSTM0TINT : OSTM_0 compare match +* : DMAC_REQ_OSTM1TINT : OSTM_1 compare match +* : DMAC_REQ_TGI0A : MTU2_0 input capture/compare match +* : : +* : uint32_t req_direction: Setting value of CHCFG_n register REQD bit +* Return Value : none +*******************************************************************************/ +void usb0_function_DMAC1_PeriReqInit (const dmac_transinfo_t * trans_info, + uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction) +{ + /* ==== Register mode ==== */ + if (DMAC_MODE_REGISTER == dmamode) + { + /* ==== Next0 register set ==== */ + DMAC1.N0SA_n = trans_info->src_addr; /* Start address of transfer source */ + DMAC1.N0DA_n = trans_info->dst_addr; /* Start address of transfer destination */ + DMAC1.N0TB_n = trans_info->count; /* Total transfer byte count */ + + /* DAD : Transfer destination address counting direction */ + /* SAD : Transfer source address counting direction */ + /* DDS : Transfer destination transfer size */ + /* SDS : Transfer source transfer size */ + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + trans_info->daddr_dir, + DMAC1_CHCFG_n_DAD_SHIFT, + DMAC1_CHCFG_n_DAD); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + trans_info->saddr_dir, + DMAC1_CHCFG_n_SAD_SHIFT, + DMAC1_CHCFG_n_SAD); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + trans_info->dst_size, + DMAC1_CHCFG_n_DDS_SHIFT, + DMAC1_CHCFG_n_DDS); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + trans_info->src_size, + DMAC1_CHCFG_n_SDS_SHIFT, + DMAC1_CHCFG_n_SDS); + + /* DMS : Register mode */ + /* RSEL : Select Next0 register set */ + /* SBE : No discharge of buffer data when aborted */ + /* DEM : No DMA interrupt mask */ + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_DMS_SHIFT, + DMAC1_CHCFG_n_DMS); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_RSEL_SHIFT, + DMAC1_CHCFG_n_RSEL); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_SBE_SHIFT, + DMAC1_CHCFG_n_SBE); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_DEM_SHIFT, + DMAC1_CHCFG_n_DEM); + + /* ---- Continuous transfer ---- */ + if (DMAC_SAMPLE_CONTINUATION == continuation) + { + /* REN : Execute continuous transfer */ + /* RSW : Change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 1, + DMAC1_CHCFG_n_REN_SHIFT, + DMAC1_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 1, + DMAC1_CHCFG_n_RSW_SHIFT, + DMAC1_CHCFG_n_RSW); + } + /* ---- Single transfer ---- */ + else + { + /* REN : Do not execute continuous transfer */ + /* RSW : Do not change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_REN_SHIFT, + DMAC1_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_RSW_SHIFT, + DMAC1_CHCFG_n_RSW); + } + + /* TM : Single transfer */ + /* SEL : Channel setting */ + /* HIEN, LOEN : On-chip peripheral module request */ + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_TM_SHIFT, + DMAC1_CHCFG_n_TM); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 1, + DMAC1_CHCFG_n_SEL_SHIFT, + DMAC1_CHCFG_n_SEL); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 1, + DMAC1_CHCFG_n_HIEN_SHIFT, + DMAC1_CHCFG_n_HIEN); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + 0, + DMAC1_CHCFG_n_LOEN_SHIFT, + DMAC1_CHCFG_n_LOEN); + + /* ---- Set factor by specified on-chip peripheral module request ---- */ + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM], + DMAC1_CHCFG_n_AM_SHIFT, + DMAC1_CHCFG_n_AM); + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL], + DMAC1_CHCFG_n_LVL_SHIFT, + DMAC1_CHCFG_n_LVL); + + if (usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE) + { + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD], + DMAC1_CHCFG_n_REQD_SHIFT, + DMAC1_CHCFG_n_REQD); + } + else + { + RZA_IO_RegWrite_32(&DMAC1.CHCFG_n, + req_direction, + DMAC1_CHCFG_n_REQD_SHIFT, + DMAC1_CHCFG_n_REQD); + } + + RZA_IO_RegWrite_32(&DMAC01.DMARS, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID], + DMAC01_DMARS_CH1_RID_SHIFT, + DMAC01_DMARS_CH1_RID); + RZA_IO_RegWrite_32(&DMAC01.DMARS, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID], + DMAC01_DMARS_CH1_MID_SHIFT, + DMAC01_DMARS_CH1_MID); + + /* PR : Round robin mode */ + RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7, + 1, + DMAC07_DCTRL_0_7_PR_SHIFT, + DMAC07_DCTRL_0_7_PR); + } +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC1_Open +* Description : Enables DMAC channel 1 transfer. +* Arguments : uint32_t req : DMAC request mode +* Return Value : 0 : Succeeded in enabling DMA transfer +* : -1 : Failed to enable DMA transfer (due to DMA operation) +*******************************************************************************/ +int32_t usb0_function_DMAC1_Open (uint32_t req) +{ + int32_t ret; + volatile uint8_t dummy; + + /* Transferable? */ + if ((0 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n, + DMAC1_CHSTAT_n_EN_SHIFT, + DMAC1_CHSTAT_n_EN)) && + (0 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n, + DMAC1_CHSTAT_n_TACT_SHIFT, + DMAC1_CHSTAT_n_TACT))) + { + /* Clear Channel Status Register */ + RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n, + 1, + DMAC1_CHCTRL_n_SWRST_SHIFT, + DMAC1_CHCTRL_n_SWRST); + dummy = RZA_IO_RegRead_32(&DMAC1.CHCTRL_n, + DMAC1_CHCTRL_n_SWRST_SHIFT, + DMAC1_CHCTRL_n_SWRST); + /* Enable DMA transfer */ + RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n, + 1, + DMAC1_CHCTRL_n_SETEN_SHIFT, + DMAC1_CHCTRL_n_SETEN); + + /* ---- Request by software ---- */ + if (DMAC_REQ_MODE_SOFT == req) + { + /* DMA transfer Request by software */ + RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n, + 1, + DMAC1_CHCTRL_n_STG_SHIFT, + DMAC1_CHCTRL_n_STG); + } + + ret = 0; + } + else + { + ret = -1; + } + + return ret; +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC1_Close +* Description : Aborts DMAC channel 1 transfer. Returns the remaining transfer +* : byte count at the time of DMA transfer abort to the argument +* : *remain. +* Arguments : uint32_t * remain : Remaining transfer byte count when +* : : DMA transfer is aborted +* Return Value : none +*******************************************************************************/ +void usb0_function_DMAC1_Close (uint32_t * remain) +{ + + /* ==== Abort transfer ==== */ + RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n, + 1, + DMAC1_CHCTRL_n_CLREN_SHIFT, + DMAC1_CHCTRL_n_CLREN); + + while (1 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n, + DMAC1_CHSTAT_n_TACT_SHIFT, + DMAC1_CHSTAT_n_TACT)) + { + /* Loop until transfer is aborted */ + } + + while (1 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n, + DMAC1_CHSTAT_n_EN_SHIFT, + DMAC1_CHSTAT_n_EN)) + { + /* Loop until 0 is set in EN before checking the remaining transfer byte count */ + } + /* ==== Obtain remaining transfer byte count ==== */ + *remain = DMAC1.CRTB_n; +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC1_Load_Set +* Description : Sets the transfer source address, transfer destination +* : address, and total transfer byte count respectively +* : specified by the argument src_addr, dst_addr, and count to +* : DMAC channel 1 as DMA transfer information. +* : Sets the register set selected by the CHCFG_n register +* : RSEL bit from the Next0 or Next1 register set. +* : This function should be called when DMA transfer of DMAC +* : channel 1 is aboted. +* Arguments : uint32_t src_addr : Transfer source address +* : uint32_t dst_addr : Transfer destination address +* : uint32_t count : Total transfer byte count +* Return Value : none +*******************************************************************************/ +void usb0_function_DMAC1_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count) +{ + uint8_t reg_set; + + /* Obtain register set in use */ + reg_set = RZA_IO_RegRead_32(&DMAC1.CHSTAT_n, + DMAC1_CHSTAT_n_SR_SHIFT, + DMAC1_CHSTAT_n_SR); + + /* ==== Load ==== */ + if (0 == reg_set) + { + /* ---- Next0 Register Set ---- */ + DMAC1.N0SA_n = src_addr; /* Start address of transfer source */ + DMAC1.N0DA_n = dst_addr; /* Start address of transfer destination */ + DMAC1.N0TB_n = count; /* Total transfer byte count */ + } + else + { + /* ---- Next1 Register Set ---- */ + DMAC1.N1SA_n = src_addr; /* Start address of transfer source */ + DMAC1.N1DA_n = dst_addr; /* Start address of transfer destination */ + DMAC1.N1TB_n = count; /* Total transfer byte count */ + } +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC2_PeriReqInit +* Description : Sets the register mode for DMA mode and the on-chip peripheral +* : module request for transfer request for DMAC channel 2. +* : Executes DMAC initial setting using the DMA information +* : specified by the argument *trans_info and the enabled/disabled +* : continuous transfer specified by the argument continuation. +* : Registers DMAC channel 2 interrupt handler function and sets +* : the interrupt priority level. Then enables transfer completion +* : interrupt. +* Arguments : dmac_transinfo_t * trans_info : Setting information to DMAC +* : : register +* : uint32_t dmamode : DMA mode (only for DMAC_MODE_REGISTER) +* : uint32_t continuation : Set continuous transfer to be valid +* : : after DMA transfer has been completed +* : DMAC_SAMPLE_CONTINUATION : Execute continuous transfer +* : DMAC_SAMPLE_SINGLE : Do not execute continuous +* : : transfer +* : uint32_t request_factor : Factor for on-chip peripheral module +* : : request +* : DMAC_REQ_OSTM0TINT : OSTM_0 compare match +* : DMAC_REQ_OSTM1TINT : OSTM_1 compare match +* : DMAC_REQ_TGI0A : MTU2_0 input capture/compare match +* : : +* : uint32_t req_direction : Setting value of CHCFG_n register +* : : REQD bit +*******************************************************************************/ +void usb0_function_DMAC2_PeriReqInit (const dmac_transinfo_t * trans_info, + uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction) +{ + /* ==== Register mode ==== */ + if (DMAC_MODE_REGISTER == dmamode) + { + /* ==== Next0 register set ==== */ + DMAC2.N0SA_n = trans_info->src_addr; /* Start address of transfer source */ + DMAC2.N0DA_n = trans_info->dst_addr; /* Start address of transfer destination */ + DMAC2.N0TB_n = trans_info->count; /* Total transfer byte count */ + + /* DAD : Transfer destination address counting direction */ + /* SAD : Transfer source address counting direction */ + /* DDS : Transfer destination transfer size */ + /* SDS : Transfer source transfer size */ + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + trans_info->daddr_dir, + DMAC2_CHCFG_n_DAD_SHIFT, + DMAC2_CHCFG_n_DAD); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + trans_info->saddr_dir, + DMAC2_CHCFG_n_SAD_SHIFT, + DMAC2_CHCFG_n_SAD); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + trans_info->dst_size, + DMAC2_CHCFG_n_DDS_SHIFT, + DMAC2_CHCFG_n_DDS); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + trans_info->src_size, + DMAC2_CHCFG_n_SDS_SHIFT, + DMAC2_CHCFG_n_SDS); + + /* DMS : Register mode */ + /* RSEL : Select Next0 register set */ + /* SBE : No discharge of buffer data when aborted */ + /* DEM : No DMA interrupt mask */ + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_DMS_SHIFT, + DMAC2_CHCFG_n_DMS); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_RSEL_SHIFT, + DMAC2_CHCFG_n_RSEL); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_SBE_SHIFT, + DMAC2_CHCFG_n_SBE); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_DEM_SHIFT, + DMAC2_CHCFG_n_DEM); + + /* ---- Continuous transfer ---- */ + if (DMAC_SAMPLE_CONTINUATION == continuation) + { + /* REN : Execute continuous transfer */ + /* RSW : Change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 1, + DMAC2_CHCFG_n_REN_SHIFT, + DMAC2_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 1, + DMAC2_CHCFG_n_RSW_SHIFT, + DMAC2_CHCFG_n_RSW); + } + /* ---- Single transfer ---- */ + else + { + /* REN : Do not execute continuous transfer */ + /* RSW : Do not change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_REN_SHIFT, + DMAC2_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_RSW_SHIFT, + DMAC2_CHCFG_n_RSW); + } + + /* TM : Single transfer */ + /* SEL : Channel setting */ + /* HIEN, LOEN : On-chip peripheral module request */ + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_TM_SHIFT, + DMAC2_CHCFG_n_TM); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 2, + DMAC2_CHCFG_n_SEL_SHIFT, + DMAC2_CHCFG_n_SEL); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 1, + DMAC2_CHCFG_n_HIEN_SHIFT, + DMAC2_CHCFG_n_HIEN); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + 0, + DMAC2_CHCFG_n_LOEN_SHIFT, + DMAC2_CHCFG_n_LOEN); + + /* ---- Set factor by specified on-chip peripheral module request ---- */ + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM], + DMAC2_CHCFG_n_AM_SHIFT, + DMAC2_CHCFG_n_AM); + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL], + DMAC2_CHCFG_n_LVL_SHIFT, + DMAC2_CHCFG_n_LVL); + if (usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE) + { + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD], + DMAC2_CHCFG_n_REQD_SHIFT, + DMAC2_CHCFG_n_REQD); + } + else + { + RZA_IO_RegWrite_32(&DMAC2.CHCFG_n, + req_direction, + DMAC2_CHCFG_n_REQD_SHIFT, + DMAC2_CHCFG_n_REQD); + } + RZA_IO_RegWrite_32(&DMAC23.DMARS, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID], + DMAC23_DMARS_CH2_RID_SHIFT, + DMAC23_DMARS_CH2_RID); + RZA_IO_RegWrite_32(&DMAC23.DMARS, + usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID], + DMAC23_DMARS_CH2_MID_SHIFT, + DMAC23_DMARS_CH2_MID); + + /* PR : Round robin mode */ + RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7, + 1, + DMAC07_DCTRL_0_7_PR_SHIFT, + DMAC07_DCTRL_0_7_PR); + } +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC2_Open +* Description : Enables DMAC channel 2 transfer. +* Arguments : uint32_t req : DMAC request mode +* Return Value : 0 : Succeeded in enabling DMA transfer +* : -1 : Failed to enable DMA transfer (due to DMA operation) +*******************************************************************************/ +int32_t usb0_function_DMAC2_Open (uint32_t req) +{ + int32_t ret; + volatile uint8_t dummy; + + /* Transferable? */ + if ((0 == RZA_IO_RegRead_32(&DMAC.CHSTAT_2, + DMAC2_CHSTAT_n_EN_SHIFT, + DMAC2_CHSTAT_n_EN)) && + (0 == RZA_IO_RegRead_32(&DMAC.CHSTAT_2, + DMAC2_CHSTAT_n_TACT_SHIFT, + DMAC2_CHSTAT_n_TACT))) + { + /* Clear Channel Status Register */ + RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n, + 1, + DMAC2_CHCTRL_n_SWRST_SHIFT, + DMAC2_CHCTRL_n_SWRST); + dummy = RZA_IO_RegRead_32(&DMAC2.CHCTRL_n, + DMAC2_CHCTRL_n_SWRST_SHIFT, + DMAC2_CHCTRL_n_SWRST); + /* Enable DMA transfer */ + RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n, + 1, + DMAC2_CHCTRL_n_SETEN_SHIFT, + DMAC2_CHCTRL_n_SETEN); + + /* ---- Request by software ---- */ + if (DMAC_REQ_MODE_SOFT == req) + { + /* DMA transfer Request by software */ + RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n, + 1, + DMAC2_CHCTRL_n_STG_SHIFT, + DMAC2_CHCTRL_n_STG); + } + + ret = 0; + } + else + { + ret = -1; + } + + return ret; +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC2_Close +* Description : Aborts DMAC channel 2 transfer. Returns the remaining transfer +* : byte count at the time of DMA transfer abort to the argument +* : *remain. +* Arguments : uint32_t * remain : Remaining transfer byte count when +* : : DMA transfer is aborted +* Return Value : none +*******************************************************************************/ +void usb0_function_DMAC2_Close (uint32_t * remain) +{ + + /* ==== Abort transfer ==== */ + RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n, + 1, + DMAC2_CHCTRL_n_CLREN_SHIFT, + DMAC2_CHCTRL_n_CLREN); + + while (1 == RZA_IO_RegRead_32(&DMAC2.CHSTAT_n, + DMAC2_CHSTAT_n_TACT_SHIFT, + DMAC2_CHSTAT_n_TACT)) + { + /* Loop until transfer is aborted */ + } + + while (1 == RZA_IO_RegRead_32(&DMAC2.CHSTAT_n, + DMAC2_CHSTAT_n_EN_SHIFT, + DMAC2_CHSTAT_n_EN)) + { + /* Loop until 0 is set in EN before checking the remaining transfer byte count */ + } + /* ==== Obtain remaining transfer byte count ==== */ + *remain = DMAC2.CRTB_n; +} + +/******************************************************************************* +* Function Name: usb0_function_DMAC2_Load_Set +* Description : Sets the transfer source address, transfer destination +* : address, and total transfer byte count respectively +* : specified by the argument src_addr, dst_addr, and count to +* : DMAC channel 2 as DMA transfer information. +* : Sets the register set selected by the CHCFG_n register +* : RSEL bit from the Next0 or Next1 register set. +* : This function should be called when DMA transfer of DMAC +* : channel 2 is aboted. +* Arguments : uint32_t src_addr : Transfer source address +* : uint32_t dst_addr : Transfer destination address +* : uint32_t count : Total transfer byte count +* Return Value : none +*******************************************************************************/ +void usb0_function_DMAC2_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count) +{ + uint8_t reg_set; + + /* Obtain register set in use */ + reg_set = RZA_IO_RegRead_32(&DMAC2.CHSTAT_n, + DMAC2_CHSTAT_n_SR_SHIFT, + DMAC2_CHSTAT_n_SR); + + /* ==== Load ==== */ + if (0 == reg_set) + { + /* ---- Next0 Register Set ---- */ + DMAC2.N0SA_n = src_addr; /* Start address of transfer source */ + DMAC2.N0DA_n = dst_addr; /* Start address of transfer destination */ + DMAC2.N0TB_n = count; /* Total transfer byte count */ + } + else + { + /* ---- Next1 Register Set ---- */ + DMAC2.N1SA_n = src_addr; /* Start address of transfer source */ + DMAC2.N1DA_n = dst_addr; /* Start address of transfer destination */ + DMAC2.N1TB_n = count; /* Total transfer byte count */ + } +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_userdef.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_userdef.c new file mode 100644 index 000000000..5449f60c7 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_userdef.c @@ -0,0 +1,762 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb0_function_userdef.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include <stdio.h> +#include "r_typedefs.h" +#include "iodefine.h" +#include "devdrv_usb_function_api.h" +#include "usb0_function_dmacdrv.h" /* common DMAC driver for USB */ + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +#define DUMMY_ACCESS OSTM0CNT + +/* #define CACHE_WRITEBACK */ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ +extern int32_t io_cwb(unsigned long start, unsigned long end); + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +static void usb0_function_enable_dmac0(uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc); +static void usb0_function_enable_dmac1(uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc); +static void Userdef_USB_usb0_function_delay_10us_2(void); + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_d0fifo_dmaintid +* Description : get D0FIFO DMA Interrupt ID +* Arguments : none +* Return Value : D0FIFO DMA Interrupt ID +*******************************************************************************/ +IRQn_Type Userdef_USB_usb0_function_d0fifo_dmaintid (void) +{ +#if 0 + return DMAINT1_IRQn; +#else + return 0xFFFF; +#endif +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_d1fifo_dmaintid +* Description : get D1FIFO DMA Interrupt ID +* Arguments : none +* Return Value : D1FIFO DMA Interrupt ID +*******************************************************************************/ +IRQn_Type Userdef_USB_usb0_function_d1fifo_dmaintid (void) +{ +#if 0 + return DMAINT1_IRQn; +#else + return 0xFFFF; +#endif +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_attach +* Description : Wait for the software of 1ms. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_attach (void) +{ + printf("\n"); + printf("channel 0 attach device\n"); + printf("\n"); +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_detach +* Description : Wait for the software of 1ms. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_detach (void) +{ + printf("\n"); + printf("channel 0 detach device\n"); + printf("\n"); +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_delay_1ms +* Description : Wait for the software of 1ms. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_delay_1ms (void) +{ + volatile int i; + volatile unsigned long tmp; + + /* + * Wait 1ms (Please change for your MCU). + */ + for (i = 0; i < 1440; ++i) + { + tmp = DUMMY_ACCESS; + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_delay_xms +* Description : Wait for the software in the period of time specified by the +* : argument. +* : Alter this function according to the user's system. +* Arguments : uint32_t msec ; Wait Time (msec) +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_delay_xms (uint32_t msec) +{ + volatile unsigned short i; + + for (i = 0; i < msec; ++i) + { + Userdef_USB_usb0_function_delay_1ms(); + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_delay_10us +* Description : Waits for software for the period specified by the argument. +* : Alter this function according to the user's system. +* Arguments : uint32_t usec ; Wait Time(x 10usec) +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_delay_10us (uint32_t usec) +{ + volatile int i; + + /* Wait 10us (Please change for your MCU) */ + for (i = 0; i < usec; ++i) + { + Userdef_USB_usb0_function_delay_10us_2(); + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_delay_10us_2 +* Description : Waits for software for the period specified by the argument. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +static void Userdef_USB_usb0_function_delay_10us_2 (void) +{ + volatile int i; + volatile unsigned long tmp; + + /* Wait 1us (Please change for your MCU) */ + for (i = 0; i < 14; ++i) + { + tmp = DUMMY_ACCESS; + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_delay_500ns +* Description : Wait for software for 500ns. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_delay_500ns (void) +{ + volatile int i; + volatile unsigned long tmp; + + /* Wait 500ns (Please change for your MCU) */ + /* Wait 500ns I clock 266MHz */ + tmp = DUMMY_ACCESS; +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_start_dma +* Description : Enables DMA transfer on the information specified by the argument. +* : Set DMAC register by this function to enable DMA transfer. +* : After executing this function, USB module is set to start DMA +* : transfer. DMA transfer should not wait for DMA transfer complete. +* Arguments : USB_FUNCTION_DMA_t *dma : DMA parameter +* : typedef struct{ +* : uint32_t fifo; FIFO for using +* : uint32_t buffer; Start address of transfer source/destination +* : uint32_t bytes; Transfer size(Byte) +* : uint32_t dir; Transfer direction(0:Buffer->FIFO, 1:FIFO->Buffer) +* : uint32_t size; DMA transfer size +* : } USB_FUNCTION_DMA_t; +* : uint16_t dfacc ; 0 : cycle steal mode +* : 1 : 16byte continuous mode +* : 2 : 32byte continuous mode +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb0_function_start_dma (USB_FUNCTION_DMA_t * dma, uint16_t dfacc) +{ + uint32_t trncount; + uint32_t src; + uint32_t dst; + uint32_t size; + uint32_t dir; +#ifdef CACHE_WRITEBACK + uint32_t ptr; +#endif + + trncount = dma->bytes; + dir = dma->dir; + + if (dir == USB_FUNCTION_FIFO2BUF) + { + /* DxFIFO determination */ + dst = dma->buffer; +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB200.D1FIFO.UINT32); + } + size = dma->size; + + if (size == 0) + { + src += 3; /* byte access */ + } + else if (size == 1) + { + src += 2; /* short access */ + } + else + { + /* Do Nothing */ + } +#else + size = dma->size; + + if (size == 2) + { + /* 32bit access */ + if (dfacc == 2) + { + /* 32byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB200.D0FIFOB0); + } + else + { + src = (uint32_t)(&USB200.D1FIFOB0); + } + } + else if (dfacc == 1) + { + /* 16byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB200.D0FIFOB0); + } + else + { + src = (uint32_t)(&USB200.D1FIFOB0); + } + } + else + { + /* normal access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB200.D1FIFO.UINT32); + } + } + } + else if (size == 1) + { + /* 16bit access */ + dfacc = 0; /* force normal access */ + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB200.D1FIFO.UINT32); + } + src += 2; /* short access */ + } + else + { + /* 8bit access */ + dfacc = 0; /* force normal access */ + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB200.D1FIFO.UINT32); + } + src += 3; /* byte access */ + } +#endif + } + else + { + /* DxFIFO determination */ + src = dma->buffer; +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB200.D1FIFO.UINT32); + } + size = dma->size; + + if (size == 0) + { + dst += 3; /* byte access */ + } + else if (size == 1) + { + dst += 2; /* short access */ + } + else + { + /* Do Nothing */ + } +#else + size = dma->size; + + if (size == 2) + { + /* 32bit access */ + if (dfacc == 2) + { + /* 32byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB200.D0FIFOB0); + } + else + { + dst = (uint32_t)(&USB200.D1FIFOB0); + } + } + else if (dfacc == 1) + { + /* 16byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB200.D0FIFOB0); + } + else + { + dst = (uint32_t)(&USB200.D1FIFOB0); + } + } + else + { + /* normal access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB200.D1FIFO.UINT32); + } + } + } + else if (size == 1) + { + /* 16bit access */ + dfacc = 0; /* force normal access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB200.D1FIFO.UINT32); + } + dst += 2; /* short access */ + } + else + { + /* 8bit access */ + dfacc = 0; /* force normal access */ + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB200.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB200.D1FIFO.UINT32); + } + dst += 3; /* byte access */ + } +#endif + } + +#ifdef CACHE_WRITEBACK + ptr = (uint32_t)dma->buffer; + + if ((ptr & 0x20000000ul) == 0) + { + io_cwb((uint32_t)ptr, (uint32_t)(ptr) + trncount); + } +#endif + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + usb0_function_enable_dmac0(src, dst, trncount, size, dir, dma->fifo, dfacc); + } + else + { + usb0_function_enable_dmac1(src, dst, trncount, size, dir, dma->fifo, dfacc); + } +} + +/******************************************************************************* +* Function Name: usb0_function_enable_dmac0 +* Description : Enables DMA transfer on the information specified by the argument. +* Arguments : uint32_t src : src address +* : uint32_t dst : dst address +* : uint32_t count : transfer byte +* : uint32_t size : transfer size +* : uint32_t dir : direction +* : uint32_t fifo : FIFO(D0FIFO or D1FIFO) +* : uint16_t dfacc : 0 : normal access +* : : 1 : 16byte access +* : : 2 : 32byte access +* Return Value : none +*******************************************************************************/ +static void usb0_function_enable_dmac0 (uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc) +{ + dmac_transinfo_t trans_info; + uint32_t request_factor = 0; + int32_t ret; + + /* ==== Variable setting for DMAC initialization ==== */ + trans_info.src_addr = (uint32_t)src; /* Start address of transfer source */ + trans_info.dst_addr = (uint32_t)dst; /* Start address of transfer destination */ + trans_info.count = (uint32_t)count; /* Total byte count to be transferred */ +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } +#else + if (dfacc == 2) + { + /* 32byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_256; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_256; /* Transfer destination transfer size */ + } + else if (dfacc == 1) + { + /* 16byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_128; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_128; /* Transfer destination transfer size */ + } + else + { + /* normal access */ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } + } +#endif + + if (dir == USB_FUNCTION_FIFO2BUF) + { + request_factor =DMAC_REQ_USB0_DMA0_RX; /* USB_0 channel 0 receive FIFO full */ + trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer destination address */ + } + else if (dir == USB_FUNCTION_BUF2FIFO) + { + request_factor =DMAC_REQ_USB0_DMA0_TX; /* USB_0 channel 0 receive FIFO empty */ + trans_info.saddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer destination address */ + } + else + { + /* Do Nothing */ + } + + /* ==== DMAC initialization ==== */ + usb0_function_DMAC1_PeriReqInit((const dmac_transinfo_t *)&trans_info, + DMAC_MODE_REGISTER, + DMAC_SAMPLE_SINGLE, + request_factor, + 0); /* Don't care DMAC_REQ_REQD is setting in + usb0_function_DMAC1_PeriReqInit() */ + + /* ==== DMAC startup ==== */ + ret = usb0_function_DMAC1_Open(DMAC_REQ_MODE_PERI); + if (ret != 0) + { + printf("DMAC1 Open error!!\n"); + } + + return; +} + +/******************************************************************************* +* Function Name: usb0_function_enable_dmac1 +* Description : Enables DMA transfer on the information specified by the argument. +* Arguments : uint32_t src : src address +* : uint32_t dst : dst address +* : uint32_t count : transfer byte +* : uint32_t size : transfer size +* : uint32_t dir : direction +* : uint32_t fifo : FIFO(D0FIFO or D1FIFO) +* : uint16_t dfacc : 0 : normal access +* : : 1 : 16byte access +* : : 2 : 32byte access +* Return Value : none +*******************************************************************************/ +static void usb0_function_enable_dmac1 (uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc) +{ + dmac_transinfo_t trans_info; + uint32_t request_factor = 0; + int32_t ret; + + /* ==== Variable setting for DMAC initialization ==== */ + trans_info.src_addr = (uint32_t)src; /* Start address of transfer source */ + trans_info.dst_addr = (uint32_t)dst; /* Start address of transfer destination */ + trans_info.count = (uint32_t)count; /* Total byte count to be transferred */ +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } +#else + if (dfacc == 2) + { + /* 32byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_256; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_256; /* Transfer destination transfer size */ + } + else if (dfacc == 1) + { + /* 16byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_128; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_128; /* Transfer destination transfer size */ + } + else + { + /* normal access */ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } + } +#endif + + if (dir == USB_FUNCTION_FIFO2BUF) + { + request_factor =DMAC_REQ_USB0_DMA1_RX; /* USB_0 channel 0 receive FIFO full */ + trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer destination address */ + } + else if (dir == USB_FUNCTION_BUF2FIFO) + { + request_factor =DMAC_REQ_USB0_DMA1_TX; /* USB_0 channel 0 receive FIFO empty */ + trans_info.saddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer destination address */ + } + else + { + /* Do Nothing */ + } + + /* ==== DMAC initialization ==== */ + usb0_function_DMAC2_PeriReqInit((const dmac_transinfo_t *)&trans_info, + DMAC_MODE_REGISTER, + DMAC_SAMPLE_SINGLE, + request_factor, + 0); /* Don't care DMAC_REQ_REQD is setting in + usb0_function_DMAC1_PeriReqInit() */ + + /* ==== DMAC startup ==== */ + ret = usb0_function_DMAC2_Open(DMAC_REQ_MODE_PERI); + if (ret != 0) + { + printf("DMAC2 Open error!!\n"); + } + + return; +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_stop_dma0 +* Description : Disables DMA transfer. +* : This function should be executed to DMAC executed at the time +* : of specification of D0_FIF0_DMA in dma->fifo. +* Arguments : none +* Return Value : uint32_t return Transfer Counter register(DMATCRn) value +* : regarding to the bus width. +*******************************************************************************/ +uint32_t Userdef_USB_usb0_function_stop_dma0 (void) +{ + uint32_t remain; + + /* ==== DMAC release ==== */ + usb0_function_DMAC1_Close(&remain); + + return remain; +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb0_function_stop_dma1 +* Description : Disables DMA transfer. +* : This function should be executed to DMAC executed at the time +* : of specification of D1_FIF0_DMA in dma->fifo. +* Arguments : none +* Return Value : uint32_t return Transfer Counter register(DMATCRn) value +* : regarding to the bus width. +*******************************************************************************/ +uint32_t Userdef_USB_usb0_function_stop_dma1 (void) +{ + uint32_t remain; + + /* ==== DMAC release ==== */ + usb0_function_DMAC2_Close(&remain); + + return remain; +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function.h new file mode 100644 index 000000000..de51053c0 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function.h @@ -0,0 +1,171 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB1_FUNCTION_H +#define USB1_FUNCTION_H + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "devdrv_usb_function_api.h" +#include "usb_function.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ +extern const uint16_t g_usb1_function_bit_set[]; +extern uint32_t g_usb1_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint8_t *g_usb1_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1]; + +extern uint16_t g_usb1_function_PipeIgnore[]; +extern uint16_t g_usb1_function_PipeTbl[]; +extern uint16_t g_usb1_function_pipe_status[]; +extern uint32_t g_usb1_function_PipeDataSize[]; + +extern USB_FUNCTION_DMA_t g_usb1_function_DmaInfo[]; +extern uint16_t g_usb1_function_DmaPipe[]; +extern uint16_t g_usb1_function_DmaBval[]; +extern uint16_t g_usb1_function_DmaStatus[]; + +extern uint16_t g_usb1_function_CtrZeroLengthFlag; + +extern uint16_t g_usb1_function_ConfigNum; +extern uint16_t g_usb1_function_Alternate[USB_FUNCTION_ALT_NO]; +extern uint16_t g_usb1_function_RemoteWakeupFlag; +extern uint16_t g_usb1_function_TestModeFlag; +extern uint16_t g_usb1_function_TestModeSelectors; + +extern uint16_t g_usb1_function_ReqType; +extern uint16_t g_usb1_function_ReqTypeType; +extern uint16_t g_usb1_function_ReqTypeRecip; +extern uint16_t g_usb1_function_ReqRequest; +extern uint16_t g_usb1_function_ReqValue; +extern uint16_t g_usb1_function_ReqIndex; +extern uint16_t g_usb1_function_ReqLength; + +extern uint16_t g_usb1_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1]; + +extern uint16_t g_usb1_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint16_t g_usb1_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint16_t g_usb1_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1]; +extern uint16_t g_usb1_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1]; + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +/* ==== common ==== */ +void usb1_function_dma_stop_d0(uint16_t pipe, uint32_t remain); +void usb1_function_dma_stop_d1(uint16_t pipe, uint32_t remain); +uint16_t usb1_function_is_hispeed(void); +uint16_t usb1_function_is_hispeed_enable(void); +uint16_t usb1_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t usb1_function_write_buffer(uint16_t pipe); +uint16_t usb1_function_write_buffer_c(uint16_t pipe); +uint16_t usb1_function_write_buffer_d0(uint16_t pipe); +uint16_t usb1_function_write_buffer_d1(uint16_t pipe); +void usb1_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t usb1_function_read_buffer(uint16_t pipe); +uint16_t usb1_function_read_buffer_c(uint16_t pipe); +uint16_t usb1_function_read_buffer_d0(uint16_t pipe); +uint16_t usb1_function_read_buffer_d1(uint16_t pipe); +uint16_t usb1_function_change_fifo_port(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void usb1_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void usb1_function_set_curpipe2(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc); +uint16_t usb1_function_get_mbw(uint32_t trncount, uint32_t dtptr); +uint16_t usb1_function_read_dma(uint16_t pipe); +void usb1_function_brdy_int(uint16_t status, uint16_t int_enb); +void usb1_function_nrdy_int(uint16_t status, uint16_t int_enb); +void usb1_function_bemp_int(uint16_t status, uint16_t int_enb); +void usb1_function_setting_interrupt(uint8_t level); +void usb1_function_reset_module(uint16_t clockmode); +uint16_t usb1_function_get_buf_size(uint16_t pipe); +uint16_t usb1_function_get_mxps(uint16_t pipe); +void usb1_function_clear_brdy_sts(uint16_t pipe); +void usb1_function_clear_bemp_sts(uint16_t pipe); +void usb1_function_clear_nrdy_sts(uint16_t pipe); +void usb1_function_set_pid_buf(uint16_t pipe); +void usb1_function_set_pid_nak(uint16_t pipe); +void usb1_function_set_pid_stall(uint16_t pipe); +void usb1_function_clear_pid_stall(uint16_t pipe); +uint16_t usb1_function_get_pid(uint16_t pipe); +void usb1_function_set_sqclr(uint16_t pipe); +void usb1_function_set_sqset(uint16_t pipe); +void usb1_function_set_csclr(uint16_t pipe); +void usb1_function_aclrm(uint16_t pipe); +void usb1_function_set_aclrm(uint16_t pipe); +void usb1_function_clr_aclrm(uint16_t pipe); +uint16_t usb1_function_get_sqmon(uint16_t pipe); +uint16_t usb1_function_get_inbuf(uint16_t pipe); + +/* ==== function ==== */ +void usb1_function_init_status(void); +void usb1_function_InitModule(uint16_t mode); +uint16_t usb1_function_CheckVBUStaus(void); +void usb1_function_USB_FUNCTION_Attach(void); +void usb1_function_USB_FUNCTION_Detach(void); +void usb1_function_USB_FUNCTION_BusReset(void); +void usb1_function_USB_FUNCTION_Resume(void); +void usb1_function_USB_FUNCTION_Suspend(void); +void usb1_function_USB_FUNCTION_TestMode(void); +void usb1_function_ResetDCP(void); +void usb1_function_ResetEP(uint16_t num); +uint16_t usb1_function_EpToPipe(uint16_t ep); +void usb1_function_InitEPTable(uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num); +uint16_t usb1_function_GetConfigNum(void); +uint16_t usb1_function_GetAltNum(uint16_t Con_Num, uint16_t Int_Num); +uint16_t usb1_function_CheckRemoteWakeup(void); +void usb1_function_clear_alt(void); +void usb1_function_clear_pipe_tbl(void); +void usb1_function_clear_ep_table_index(void); +uint16_t usb1_function_GetInterfaceNum(uint16_t num); + +#ifdef __cplusplus +} +#endif + + +#endif /* USB1_FUNCTION_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_api.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_api.h new file mode 100644 index 000000000..7e78076d9 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_api.h @@ -0,0 +1,104 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_api.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB1_FUNCTION_API_H +#define USB1_FUNCTION_API_H + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Variable Externs +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +void usb1_api_function_init(uint8_t int_level, uint16_t mode, uint16_t clockmode); +uint16_t usb1_api_function_IsConfigured(void); +uint16_t usb1_function_GetDeviceState(void); +uint16_t usb1_api_function_CtrlReadStart(uint32_t size, uint8_t *data); +void usb1_api_function_CtrlWriteStart(uint32_t size, uint8_t *data); +uint16_t usb1_api_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +uint16_t usb1_api_function_check_pipe_status(uint16_t pipe, uint32_t *size); +void usb1_api_function_clear_pipe_status(uint16_t pipe); +void usb1_api_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data); +void usb1_api_function_set_pid_buf(uint16_t pipe); +void usb1_api_function_set_pid_nak(uint16_t pipe); +void usb1_api_function_set_pid_stall(uint16_t pipe); +void usb1_api_function_clear_pid_stall(uint16_t pipe); +uint16_t usb1_api_function_get_pid(uint16_t pipe); +int32_t usb1_api_function_check_stall(uint16_t pipe); +void usb1_api_function_set_sqclr(uint16_t pipe); +void usb1_api_function_set_sqset(uint16_t pipe); +void usb1_api_function_set_csclr(uint16_t pipe); +void usb1_api_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw); +void usb1_api_function_clear_brdy_sts(uint16_t pipe); +void usb1_api_function_clear_bemp_sts(uint16_t pipe); +void usb1_api_function_clear_nrdy_sts(uint16_t pipe); + +void usb1_function_ClearFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_SetFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_SetAddress(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_SetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_SetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_SetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_SynchFrame(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_GetStatus(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_GetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_GetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_GetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Resrv_0(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Resrv_123(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Resrv_4(uint16_t type, uint16_t value, uint16_t index, uint16_t length); +void usb1_function_Resrv_5(uint16_t type, uint16_t value, uint16_t index, uint16_t length); + +#ifdef __cplusplus +} +#endif + +#endif /* USB1_FUNCTION_API_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_dmacdrv.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_dmacdrv.h new file mode 100644 index 000000000..a4882f8fa --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_dmacdrv.h @@ -0,0 +1,142 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_dmacdrv.h +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Description : RZ/A1H R7S72100 USB Sample Program +*******************************************************************************/ +#ifndef USB1_FUNCTION_DMACDRV_H +#define USB1_FUNCTION_DMACDRV_H + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ + + +#ifdef __cplusplus +extern "C" { +#endif + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ +typedef struct dmac_transinfo +{ + uint32_t src_addr; /* Transfer source address */ + uint32_t dst_addr; /* Transfer destination address */ + uint32_t count; /* Transfer byte count */ + uint32_t src_size; /* Transfer source data size */ + uint32_t dst_size; /* Transfer destination data size */ + uint32_t saddr_dir; /* Transfer source address direction */ + uint32_t daddr_dir; /* Transfer destination address direction */ +} dmac_transinfo_t; + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +/* ==== Transfer specification of the sample program ==== */ +#define DMAC_SAMPLE_SINGLE (0) /* Single transfer */ +#define DMAC_SAMPLE_CONTINUATION (1) /* Continuous transfer (use REN bit) */ + +/* ==== DMA modes ==== */ +#define DMAC_MODE_REGISTER (0) /* Register mode */ +#define DMAC_MODE_LINK (1) /* Link mode */ + +/* ==== Transfer requests ==== */ +#define DMAC_REQ_MODE_EXT (0) /* External request */ +#define DMAC_REQ_MODE_PERI (1) /* On-chip peripheral module request */ +#define DMAC_REQ_MODE_SOFT (2) /* Auto-request (request by software) */ + +/* ==== DMAC transfer sizes ==== */ +#define DMAC_TRANS_SIZE_8 (0) /* 8 bits */ +#define DMAC_TRANS_SIZE_16 (1) /* 16 bits */ +#define DMAC_TRANS_SIZE_32 (2) /* 32 bits */ +#define DMAC_TRANS_SIZE_64 (3) /* 64 bits */ +#define DMAC_TRANS_SIZE_128 (4) /* 128 bits */ +#define DMAC_TRANS_SIZE_256 (5) /* 256 bits */ +#define DMAC_TRANS_SIZE_512 (6) /* 512 bits */ +#define DMAC_TRANS_SIZE_1024 (7) /* 1024 bits */ + +/* ==== Address increment for transferring ==== */ +#define DMAC_TRANS_ADR_NO_INC (1) /* Not increment */ +#define DMAC_TRANS_ADR_INC (0) /* Increment */ + +/* ==== Method for detecting DMA request ==== */ +#define DMAC_REQ_DET_FALL (0) /* Falling edge detection */ +#define DMAC_REQ_DET_RISE (1) /* Rising edge detection */ +#define DMAC_REQ_DET_LOW (2) /* Low level detection */ +#define DMAC_REQ_DET_HIGH (3) /* High level detection */ + +/* ==== Request Direction ==== */ +#define DMAC_REQ_DIR_SRC (0) /* DMAREQ is the source/ DMAACK is active when reading */ +#define DMAC_REQ_DIR_DST (1) /* DMAREQ is the destination/ DMAACK is active when writing */ + +/* ==== Descriptors ==== */ +#define DMAC_DESC_HEADER (0) /* Header */ +#define DMAC_DESC_SRC_ADDR (1) /* Source Address */ +#define DMAC_DESC_DST_ADDR (2) /* Destination Address */ +#define DMAC_DESC_COUNT (3) /* Transaction Byte */ +#define DMAC_DESC_CHCFG (4) /* Channel Confg */ +#define DMAC_DESC_CHITVL (5) /* Channel Interval */ +#define DMAC_DESC_CHEXT (6) /* Channel Extension */ +#define DMAC_DESC_LINK_ADDR (7) /* Link Address */ + +/* ==== On-chip peripheral module requests ===== */ +typedef enum dmac_request_factor +{ + DMAC_REQ_USB0_DMA0_TX, /* USB_0 channel 0 transmit FIFO empty */ + DMAC_REQ_USB0_DMA0_RX, /* USB_0 channel 0 receive FIFO full */ + DMAC_REQ_USB0_DMA1_TX, /* USB_0 channel 1 transmit FIFO empty */ + DMAC_REQ_USB0_DMA1_RX, /* USB_0 channel 1 receive FIFO full */ + DMAC_REQ_USB1_DMA0_TX, /* USB_1 channel 0 transmit FIFO empty */ + DMAC_REQ_USB1_DMA0_RX, /* USB_1 channel 0 receive FIFO full */ + DMAC_REQ_USB1_DMA1_TX, /* USB_1 channel 1 transmit FIFO empty */ + DMAC_REQ_USB1_DMA1_RX, /* USB_1 channel 1 receive FIFO full */ +} dmac_request_factor_t; + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +void usb1_function_DMAC3_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction); +int32_t usb1_function_DMAC3_Open(uint32_t req); +void usb1_function_DMAC3_Close(uint32_t *remain); +void usb1_function_DMAC3_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count); + +void usb1_function_DMAC4_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction); +int32_t usb1_function_DMAC4_Open(uint32_t req); +void usb1_function_DMAC4_Close(uint32_t *remain); +void usb1_function_DMAC4_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count); + +#ifdef __cplusplus +} +#endif + +#endif /* USB1_FUNCTION_DMACDRV_H */ + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dataio.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dataio.c new file mode 100644 index 000000000..cf088b60f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dataio.c @@ -0,0 +1,2932 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_dataio.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +static uint16_t g_usb1_function_mbw[(USB_FUNCTION_MAX_PIPE_NO + 1)]; + +static void usb1_function_start_receive_trns_c(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb1_function_start_receive_trns_d0(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb1_function_start_receive_trns_d1(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb1_function_start_receive_dma_d0(uint16_t pipe, uint32_t size, uint8_t *data); +static void usb1_function_start_receive_dma_d1(uint16_t pipe, uint32_t size, uint8_t *data); +static uint16_t usb1_function_read_dma_d0(uint16_t pipe); +static uint16_t usb1_function_read_dma_d1(uint16_t pipe); +static uint16_t usb1_function_write_dma_d0(uint16_t pipe); +static uint16_t usb1_function_write_dma_d1(uint16_t pipe); + +static void usb1_function_read_c_fifo(uint16_t pipe, uint16_t count); +static void usb1_function_write_c_fifo(uint16_t Pipe, uint16_t count); +static void usb1_function_read_d0_fifo(uint16_t pipe, uint16_t count); +static void usb1_function_write_d0_fifo(uint16_t pipe, uint16_t count); +static void usb1_function_read_d1_fifo(uint16_t pipe, uint16_t count); +static void usb1_function_write_d1_fifo(uint16_t pipe, uint16_t count); + +static void usb1_function_clear_transaction_counter(uint16_t pipe); +static void usb1_function_set_transaction_counter(uint16_t pipe, uint32_t count); + +static uint32_t usb1_function_com_get_dmasize(uint32_t trncount, uint32_t dtptr); + +static uint16_t usb1_function_set_dfacc_d0(uint16_t mbw, uint32_t count); +static uint16_t usb1_function_set_dfacc_d1(uint16_t mbw, uint32_t count); + + +/******************************************************************************* +* Function Name: usb1_function_start_send_transfer +* Description : Starts the USB data communication using pipe specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t status; + uint16_t usefifo; + uint16_t mbw; + + g_usb1_function_data_count[pipe] = size; + g_usb1_function_data_pointer[pipe] = (uint8_t *)data; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + usb1_function_clear_bemp_sts(pipe); + usb1_function_clear_brdy_sts(pipe); + usb1_function_clear_nrdy_sts(pipe); + + mbw = usb1_function_get_mbw(size, (uint32_t)data); + + usefifo = (uint16_t)(g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + case USB_FUNCTION_D0FIFO_DMA: + usefifo = USB_FUNCTION_D0USE; + break; + + case USB_FUNCTION_D1FIFO_USE: + case USB_FUNCTION_D1FIFO_DMA: + usefifo = USB_FUNCTION_D1USE; + break; + + default: + usefifo = USB_FUNCTION_CUSE; + break; + }; + + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, usefifo, DEVDRV_USBF_NO, mbw); + + usb1_function_clear_transaction_counter(pipe); + + usb1_function_aclrm(pipe); + + status = usb1_function_write_buffer(pipe); + + if (status != DEVDRV_USBF_FIFOERROR) + { + usb1_function_set_pid_buf(pipe); + } + + return status; +} + +/******************************************************************************* +* Function Name: usb1_function_write_buffer +* Description : Writes data in the buffer allocated in the pipe specified by +* : the argument. The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_write_buffer (uint16_t pipe) +{ + uint16_t status; + uint16_t usefifo; + + g_usb1_function_PipeIgnore[pipe] = 0; + usefifo = (uint16_t)(g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + status = usb1_function_write_buffer_d0(pipe); + break; + + case USB_FUNCTION_D1FIFO_USE: + status = usb1_function_write_buffer_d1(pipe); + break; + + case USB_FUNCTION_D0FIFO_DMA: + status = usb1_function_write_dma_d0(pipe); + break; + + case USB_FUNCTION_D1FIFO_DMA: + status = usb1_function_write_dma_d1(pipe); + break; + + default: + status = usb1_function_write_buffer_c(pipe); + break; + }; + + switch (status) + { + case DEVDRV_USBF_WRITING: /* Continue of data write */ + usb1_function_enable_nrdy_int(pipe); /* Error (NORES or STALL) */ + usb1_function_enable_brdy_int(pipe); /* Enable Ready Interrupt */ + break; + + case DEVDRV_USBF_WRITEEND: /* End of data write */ + case DEVDRV_USBF_WRITESHRT: /* End of data write */ + usb1_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + usb1_function_clear_nrdy_sts(pipe); + usb1_function_enable_nrdy_int(pipe); /* Error (NORES or STALL) */ + /* for last transfer */ + usb1_function_enable_bemp_int(pipe); /* Enable Empty Interrupt */ + break; + + case DEVDRV_USBF_WRITEDMA: /* DMA write */ + usb1_function_clear_nrdy_sts(pipe); + usb1_function_enable_nrdy_int(pipe); /* Error (NORES or STALL) */ + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access status */ + default: + usb1_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + usb1_function_disable_bemp_int(pipe); /* Disable Empty Interrupt */ + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_write_buffer_c +* Description : Writes data in the buffer allocated in the pipe specified in +* : the argument. Writes data by CPU transfer using CFIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_write_buffer_c (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + if (g_usb1_function_CtrZeroLengthFlag == 1) + { + g_usb1_function_CtrZeroLengthFlag = 0; /* Zero Length Packet Flag CLR */ + return DEVDRV_USBF_WRITEEND; + } + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + if (pipe == USB_FUNCTION_PIPE0) + { + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw); + } + else + { + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw); + } + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] <= (uint32_t)size) + { + status = DEVDRV_USBF_WRITEEND; /* write continues */ + count = g_usb1_function_data_count[pipe]; + + if (count == 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Null Packet is end of write */ + } + + if ((count % mxps) != 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + } + else + { + status = DEVDRV_USBF_WRITING; /* write continues */ + count = (uint32_t)size; + } + + usb1_function_write_c_fifo(pipe, (uint16_t)count); + + if (g_usb1_function_data_count[pipe] < (uint32_t)size) + { + g_usb1_function_data_count[pipe] = 0; + + if (RZA_IO_RegRead_16(&USB201.CFIFOCTR, USB_CFIFOCTR_BVAL_SHIFT, USB_CFIFOCTR_BVAL) == 0) + { + USB201.CFIFOCTR = USB_FUNCTION_BITBVAL; /* Short Packet */ + g_usb1_function_CtrZeroLengthFlag = 1; /* Zero Length Packet Flag */ + } + } + else + { + g_usb1_function_data_count[pipe] -= count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_write_buffer_d0 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by CPU transfer using D0FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_write_buffer_d0 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] <= (uint32_t)size) + { + status = DEVDRV_USBF_WRITEEND; /* write continues */ + count = g_usb1_function_data_count[pipe]; + + if (count == 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Null Packet is end of write */ + } + + if ((count % mxps) != 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + } + else + { + status = DEVDRV_USBF_WRITING; /* write continues */ + count = (uint32_t)size; + } + + usb1_function_write_d0_fifo(pipe, (uint16_t)count); + + if (g_usb1_function_data_count[pipe] < (uint32_t)size) + { + g_usb1_function_data_count[pipe] = 0; + if (RZA_IO_RegRead_16(&USB201.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + USB201.D0FIFOCTR = USB_FUNCTION_BITBVAL; /* Short Packet */ + } + } + else + { + g_usb1_function_data_count[pipe] -= count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_write_buffer_d1 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by CPU transfer using D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_write_buffer_d1 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] <= (uint32_t)size) + { + status = DEVDRV_USBF_WRITEEND; /* write continues */ + count = g_usb1_function_data_count[pipe]; + + if (count == 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Null Packet is end of write */ + } + + if ((count % mxps) != 0) + { + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + } + else + { + status = DEVDRV_USBF_WRITING; /* write continues */ + count = (uint32_t)size; + } + + usb1_function_write_d1_fifo(pipe, (uint16_t)count); + + if (g_usb1_function_data_count[pipe] < (uint32_t)size) + { + g_usb1_function_data_count[pipe] = 0; + + if (RZA_IO_RegRead_16(&USB201.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + USB201.D1FIFOCTR = USB_FUNCTION_BITBVAL; /* Short Packet */ + } + } + else + { + g_usb1_function_data_count[pipe] -= count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_write_dma_d0 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by DMA transfer using D0FIFO. +* : The DMA-ch for using is specified by Userdef_USB_usb1_function_start_dma(). +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND : Write end +* : DEVDRV_USBF_WRITESHRT : short data +* : DEVDRV_USBF_WRITING : Continue of data write +* : DEVDRV_USBF_WRITEDMA : Write DMA +* : DEVDRV_USBF_FIFOERROR : FIFO status +*******************************************************************************/ +static uint16_t usb1_function_write_dma_d0 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t status; + uint16_t mbw; + uint16_t dfacc = 0; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + count = g_usb1_function_data_count[pipe]; + + if (count != 0) + { + g_usb1_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe; + + if ((count % size) != 0) + { + g_usb1_function_DmaBval[USB_FUNCTION_D0FIFO] = 1; + } + else + { + g_usb1_function_DmaBval[USB_FUNCTION_D0FIFO] = 0; + } + + dfacc = usb1_function_set_dfacc_d0(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0; /* 8bit transfer */ + } + + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo = USB_FUNCTION_D0FIFO_DMA; + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].dir = USB_FUNCTION_BUF2FIFO; + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb1_function_data_pointer[pipe]; + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes = count; + + Userdef_USB_usb1_function_start_dma(&g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc); + + usb1_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB201.D0FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); + + g_usb1_function_data_count[pipe] = 0; + g_usb1_function_data_pointer[pipe] += count; + status = DEVDRV_USBF_WRITEDMA; /* DMA write */ + } + else + { + if (RZA_IO_RegRead_16(&USB201.D0FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + RZA_IO_RegWrite_16(&USB201.D0FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */ + } + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_write_dma_d1 +* Description : Writes data in the buffer allocated in the pipe specified in the argument. +* : Writes data by DMA transfer using D1FIFO. +* : The DMA-ch for using is specified by Userdef_USB_usb1_function_start_dma(). +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : DEVDRV_USBF_WRITEEND : Write end +* : DEVDRV_USBF_WRITESHRT : short data +* : DEVDRV_USBF_WRITING : Continue of data write +* : DEVDRV_USBF_WRITEDMA : Write DMA +* : DEVDRV_USBF_FIFOERROR : FIFO status +*******************************************************************************/ +static uint16_t usb1_function_write_dma_d1 (uint16_t pipe) +{ + uint32_t count; + uint16_t size; + uint16_t buffer; + uint16_t status; + uint16_t mbw; + uint16_t dfacc=0; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + count = g_usb1_function_data_count[pipe]; + + if (count != 0) + { + g_usb1_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe; + if ((count % size) != 0) + { + g_usb1_function_DmaBval[USB_FUNCTION_D1FIFO] = 1; + } + else + { + g_usb1_function_DmaBval[USB_FUNCTION_D1FIFO] = 0; + } + + dfacc = usb1_function_set_dfacc_d1(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0; /* 8bit transfer */ + } + + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo = USB_FUNCTION_D1FIFO_DMA; + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].dir = USB_FUNCTION_BUF2FIFO; + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb1_function_data_pointer[pipe]; + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes = count; + + Userdef_USB_usb1_function_start_dma(&g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc); + + usb1_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB201.D1FIFOSEL, 1, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); + + g_usb1_function_data_count[pipe] = 0; + g_usb1_function_data_pointer[pipe] += count; + + status = DEVDRV_USBF_WRITEDMA; /* DMA write */ + } + else + { + if (RZA_IO_RegRead_16(&USB201.D1FIFOCTR, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL) == 0) + { + RZA_IO_RegWrite_16(&USB201.D1FIFOCTR, 1, USB_DnFIFOCTR_BVAL_SHIFT, USB_DnFIFOCTR_BVAL); /* Short Packet */ + } + status = DEVDRV_USBF_WRITESHRT; /* Short Packet is end of write */ + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_start_receive_transfer +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +void usb1_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t usefifo; + + usb1_function_clear_bemp_sts(pipe); + usb1_function_clear_brdy_sts(pipe); + usb1_function_clear_nrdy_sts(pipe); + + usefifo = (uint16_t)(g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + usb1_function_start_receive_trns_d0(pipe, size, data); + break; + + case USB_FUNCTION_D1FIFO_USE: + usb1_function_start_receive_trns_d1(pipe, size, data); + break; + + case USB_FUNCTION_D0FIFO_DMA: + usb1_function_start_receive_dma_d0(pipe, size, data); + break; + + case USB_FUNCTION_D1FIFO_DMA: + usb1_function_start_receive_dma_d1(pipe, size, data); + break; + + default: + usb1_function_start_receive_trns_c(pipe, size, data); + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_start_receive_trns_c +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using CFIFO. +* : When storing data in the buffer allocated in the pipe specified in the +* : argument, BRDY interrupt is generated to read data +* : in the interrupt. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb1_function_start_receive_trns_c (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb1_function_set_pid_nak(pipe); + g_usb1_function_data_count[pipe] = size; + g_usb1_function_data_pointer[pipe] = (uint8_t *)data; + g_usb1_function_PipeIgnore[pipe] = 0; + + g_usb1_function_PipeDataSize[pipe] = size; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb1_function_get_mbw(size, (uint32_t)data); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw); + USB201.CFIFOCTR = USB_FUNCTION_BITBCLR; + + usb1_function_set_transaction_counter(pipe, size); + + usb1_function_aclrm(pipe); + + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + + usb1_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_start_receive_trns_d0 +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using D0FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, BRDY interrupt is generated to read data in the +* : interrupt. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb1_function_start_receive_trns_d0 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb1_function_set_pid_nak(pipe); + g_usb1_function_data_count[pipe] = size; + g_usb1_function_data_pointer[pipe] = (uint8_t *)data; + g_usb1_function_PipeIgnore[pipe] = 0; + + g_usb1_function_PipeDataSize[pipe] = size; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb1_function_get_mbw(size, (uint32_t)data); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + + usb1_function_set_transaction_counter(pipe, size); + + usb1_function_aclrm(pipe); + + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + + usb1_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_start_receive_trns_d1 +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using D1FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, BRDY interrupt is generated to read data. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb1_function_start_receive_trns_d1 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb1_function_set_pid_nak(pipe); + g_usb1_function_data_count[pipe] = size; + g_usb1_function_data_pointer[pipe] = (uint8_t *)data; + g_usb1_function_PipeIgnore[pipe] = 0; + + g_usb1_function_PipeDataSize[pipe] = size; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb1_function_get_mbw(size, (uint32_t)data); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + usb1_function_set_transaction_counter(pipe, size); + + usb1_function_aclrm(pipe); + + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + + usb1_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_start_receive_dma_d0 +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by DMA transfer using D0FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, delivered read request to DMAC to read data from +* : the buffer by DMAC. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb1_function_start_receive_dma_d0 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb1_function_set_pid_nak(pipe); + g_usb1_function_data_count[pipe] = size; + g_usb1_function_data_pointer[pipe] = (uint8_t *)data; + g_usb1_function_PipeIgnore[pipe] = 0; + + g_usb1_function_PipeDataSize[pipe] = 0; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb1_function_get_mbw(size, (uint32_t)data); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + + usb1_function_set_transaction_counter(pipe, size); + + usb1_function_aclrm(pipe); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + usb1_function_read_dma(pipe); + + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + } + else + { + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + } + + usb1_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_start_receive_dma_d1 +* Description : Read data from the buffer allocated in the pipe specified in the argument. +* : Reads data by DMA transfer using D0FIFO. +* : This function does not read data from the buffer. +* : When storing data in the buffer allocated in the pipe specified +* : in the argument, delivered read request to DMAC to read data from +* : the buffer by DMAC. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +static void usb1_function_start_receive_dma_d1 (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb1_function_set_pid_nak(pipe); + g_usb1_function_data_count[pipe] = size; + g_usb1_function_data_pointer[pipe] = (uint8_t *)data; + g_usb1_function_PipeIgnore[pipe] = 0; + + g_usb1_function_PipeDataSize[pipe] = 0; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_WAIT; + + mbw = usb1_function_get_mbw(size, (uint32_t)data); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + usb1_function_set_transaction_counter(pipe, size); + + usb1_function_aclrm(pipe); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + usb1_function_read_dma(pipe); + + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + } + else + { + usb1_function_enable_nrdy_int(pipe); + usb1_function_enable_brdy_int(pipe); + } + + usb1_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_read_buffer +* Description : Reads data from the buffer allocated in the pipe specified +* : in the argument. +* : Uses FIF0 set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_read_buffer (uint16_t pipe) +{ + uint16_t status; + + g_usb1_function_PipeIgnore[pipe] = 0; + + if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE) + { + status = usb1_function_read_buffer_d0(pipe); + } + else if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE) + { + status = usb1_function_read_buffer_d1(pipe); + } + else + { + status = usb1_function_read_buffer_c(pipe); + } + + switch (status) + { + case USB_FUNCTION_READING: /* Continue of data read */ + break; + + case USB_FUNCTION_READEND: /* End of data read */ + case USB_FUNCTION_READSHRT: /* End of data read */ + usb1_function_disable_brdy_int(pipe); + g_usb1_function_PipeDataSize[pipe] -= g_usb1_function_data_count[pipe]; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + break; + + case USB_FUNCTION_READOVER: /* buffer over */ + if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_USE) + { + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_USE) + { + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + USB201.CFIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + usb1_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + g_usb1_function_PipeDataSize[pipe] -= g_usb1_function_data_count[pipe]; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access status */ + default: + usb1_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_read_buffer_c +* Description : Reads data from the buffer allocated in the pipe specified in the argument. +* : Reads data by CPU transfer using CFIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_read_buffer_c (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_CUSE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + usb1_function_set_pid_nak(pipe); /* Set NAK */ + count = g_usb1_function_data_count[pipe]; + } + else if (g_usb1_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + usb1_function_set_pid_nak(pipe); /* Set NAK */ + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + } + + if (count == 0) /* 0 length packet */ + { + USB201.CFIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + usb1_function_read_c_fifo(pipe, (uint16_t)count); + } + + g_usb1_function_data_count[pipe] -= count; + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_read_buffer_d0 +* Description : Reads data from the buffer allocated in the pipe specified in +* : the argument. +* : Reads data by CPU transfer using D0FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_read_buffer_d0 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t pipebuf_size; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + usb1_function_set_pid_nak(pipe); /* Set NAK */ + count = g_usb1_function_data_count[pipe]; + } + else if (g_usb1_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + usb1_function_set_pid_nak(pipe); /* Set NAK */ + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + else + { + pipebuf_size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + } + } + + if (count == 0) /* 0 length packet */ + { + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + usb1_function_read_d0_fifo(pipe, (uint16_t)count); + } + + g_usb1_function_data_count[pipe] -= count; + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_read_buffer_d1 +* Description : Reads data from the buffer allocated in the pipe specified +* : in the argument. +* : Reads data by CPU transfer using D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_read_buffer_d1 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t pipebuf_size; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + usb1_function_set_pid_nak(pipe); /* Set NAK */ + count = g_usb1_function_data_count[pipe]; + } + else if (g_usb1_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + usb1_function_set_pid_nak(pipe); /* Set NAK */ + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + else + { + pipebuf_size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + usb1_function_set_pid_nak(pipe); /* Set NAK */ + } + } + } + + if (count == 0) /* 0 length packet */ + { + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + } + else + { + usb1_function_read_d1_fifo(pipe, (uint16_t)count); + } + + g_usb1_function_data_count[pipe] -= count; + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_read_dma +* Description : Reads data from the buffer allocated in the pipe specified +* : in the argument. +* : Reads data by DMA transfer using D0FIFO or D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_function_read_dma (uint16_t pipe) +{ + uint16_t status; + + g_usb1_function_PipeIgnore[pipe] = 0; + if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) + { + status = usb1_function_read_dma_d0(pipe); + } + else + { + status = usb1_function_read_dma_d1(pipe); + } + + switch (status) + { + case USB_FUNCTION_READING: /* Continue of data read */ + break; + + case USB_FUNCTION_READZERO: /* End of data read */ + usb1_function_disable_brdy_int(pipe); + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + break; + + case USB_FUNCTION_READEND: /* End of data read */ + case USB_FUNCTION_READSHRT: /* End of data read */ + usb1_function_disable_brdy_int(pipe); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + g_usb1_function_PipeDataSize[pipe] -= g_usb1_function_data_count[pipe]; + } + break; + + case USB_FUNCTION_READOVER: /* buffer over */ + usb1_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + g_usb1_function_PipeDataSize[pipe] -= g_usb1_function_data_count[pipe]; + } + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access status */ + default: + usb1_function_disable_brdy_int(pipe); /* Disable Ready Interrupt */ + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_FIFOERROR; + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_read_dma_d0 +* Description : Writes data in the buffer allocated in the pipe specified +* : in the argument. +* : Reads data by DMA transfer using D0FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READZERO ; zero data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +static uint16_t usb1_function_read_dma_d0 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t dfacc = 0; + uint16_t pipebuf_size; + + g_usb1_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + count = g_usb1_function_data_count[pipe]; + status = USB_FUNCTION_READING; + } + else + { + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw); + + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + count = g_usb1_function_data_count[pipe]; + } + else if (g_usb1_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + else + { + pipebuf_size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + } + } + + if (count == 0) /* 0 length packet */ + { + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + status = USB_FUNCTION_READZERO; /* Null Packet receive */ + } + else + { + usb1_function_set_curpipe(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw); + /* transaction counter No set */ + /* FRDY = 1, DTLN = 0 -> BRDY */ + } + } + else + { + dfacc = usb1_function_set_dfacc_d0(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size = 0; /* 8bit transfer */ + } + + g_usb1_function_DmaPipe[USB_FUNCTION_D0FIFO] = pipe; /* not use in read operation */ + g_usb1_function_DmaBval[USB_FUNCTION_D0FIFO] = 0; /* not use in read operation */ + + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].fifo = USB_FUNCTION_D0FIFO_DMA; + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].dir = USB_FUNCTION_FIFO2BUF; + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].buffer = (uint32_t)g_usb1_function_data_pointer[pipe]; + g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].bytes = count; + + if (status == USB_FUNCTION_READING) + { + g_usb1_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSY; + } + else + { + g_usb1_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_BUSYEND; + } + + Userdef_USB_usb1_function_start_dma(&g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO], dfacc); + + usb1_function_set_curpipe2(pipe, USB_FUNCTION_D0DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB201.D0FIFOSEL, + 1, + USB_DnFIFOSEL_DREQE_SHIFT, + USB_DnFIFOSEL_DREQE); + } + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + g_usb1_function_data_count[pipe] -= count; + g_usb1_function_data_pointer[pipe] += count; + g_usb1_function_PipeDataSize[pipe] += count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_read_dma_d1 +* Description : Reads data from the buffer allocated in the pipe specified in +* : the argument. +* : Reads data by DMA transfer using D1FIFO. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : USB_FUNCTION_READEND ; Read end +* : USB_FUNCTION_READSHRT ; short data +* : USB_FUNCTION_READZERO ; zero data +* : USB_FUNCTION_READING ; Continue of data read +* : USB_FUNCTION_READOVER ; buffer over +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +static uint16_t usb1_function_read_dma_d1 (uint16_t pipe) +{ + uint32_t count; + uint32_t dtln; + uint16_t buffer; + uint16_t mxps; + uint16_t status; + uint16_t mbw; + uint16_t dfacc = 0; + uint16_t pipebuf_size; + + g_usb1_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[pipe], (uint32_t)g_usb1_function_data_pointer[pipe]); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + count = g_usb1_function_data_count[pipe]; + status = USB_FUNCTION_READING; + } + else + { + buffer = usb1_function_change_fifo_port(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw); + if (buffer == DEVDRV_USBF_FIFOERROR) /* FIFO access status */ + { + return DEVDRV_USBF_FIFOERROR; + } + + dtln = (uint32_t)(buffer & USB_FUNCTION_BITDTLN); + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if (g_usb1_function_data_count[pipe] < dtln) /* Buffer Over ? */ + { + status = USB_FUNCTION_READOVER; + count = g_usb1_function_data_count[pipe]; + } + else if (g_usb1_function_data_count[pipe] == dtln) /* just Receive Size */ + { + status = USB_FUNCTION_READEND; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + else /* continue Receive data */ + { + status = USB_FUNCTION_READING; + count = dtln; + if (count == 0) + { + status = USB_FUNCTION_READSHRT; /* Null Packet receive */ + } + + if ((count % mxps) != 0) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + else + { + pipebuf_size = usb1_function_get_buf_size(pipe); /* Data buffer size */ + if (count != pipebuf_size) + { + status = USB_FUNCTION_READSHRT; /* Short Packet receive */ + } + } + } + } + + if (count == 0) /* 0 length packet */ + { + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Clear BCLR */ + status = USB_FUNCTION_READZERO; /* Null Packet receive */ + } + else + { + usb1_function_set_curpipe(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw); + /* transaction counter No set */ + /* FRDY = 1, DTLN = 0 -> BRDY */ + } + } + else + { + dfacc = usb1_function_set_dfacc_d1(mbw, count); + + if (mbw == USB_FUNCTION_BITMBW_32) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 2; /* 32bit transfer */ + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 1; /* 16bit transfer */ + } + else + { + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size = 0; /* 8bit transfer */ + } + + g_usb1_function_DmaPipe[USB_FUNCTION_D1FIFO] = pipe; /* not use in read operation */ + g_usb1_function_DmaBval[USB_FUNCTION_D1FIFO] = 0; /* not use in read operation */ + + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].fifo = USB_FUNCTION_D1FIFO_DMA; + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].dir = USB_FUNCTION_FIFO2BUF; + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].buffer = (uint32_t)g_usb1_function_data_pointer[pipe]; + g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].bytes = count; + + if (status == USB_FUNCTION_READING) + { + g_usb1_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSY; + } + else + { + g_usb1_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_BUSYEND; + } + + Userdef_USB_usb1_function_start_dma(&g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO], dfacc); + + usb1_function_set_curpipe2(pipe, USB_FUNCTION_D1DMA, DEVDRV_USBF_NO, mbw, dfacc); + + RZA_IO_RegWrite_16(&USB201.D1FIFOSEL, + 1, + USB_DnFIFOSEL_DREQE_SHIFT, + USB_DnFIFOSEL_DREQE); + } + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + g_usb1_function_data_count[pipe] -= count; + g_usb1_function_data_pointer[pipe] += count; + g_usb1_function_PipeDataSize[pipe] += count; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_function_change_fifo_port +* Description : Allocates FIF0 specified by the argument in the pipe assigned +* : by the argument. After allocating FIF0, waits in the software +* : till the corresponding pipe becomes ready. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* Return Value : DEVDRV_USBF_FIFOERROR ; Error +* : Others ; CFIFOCTR/D0FIFOCTR/D1FIFOCTR Register Value +*******************************************************************************/ +uint16_t usb1_function_change_fifo_port (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw) +{ + uint16_t buffer; + uint32_t loop; + volatile uint32_t loop2; + + usb1_function_set_curpipe(pipe, fifosel, isel, mbw); + + for (loop = 0; loop < 4; loop++) + { + switch (fifosel) + { + case USB_FUNCTION_CUSE: + buffer = USB201.CFIFOCTR; + break; + + case USB_FUNCTION_D0USE: + case USB_FUNCTION_D0DMA: + buffer = USB201.D0FIFOCTR; + break; + + case USB_FUNCTION_D1USE: + case USB_FUNCTION_D1DMA: + buffer = USB201.D1FIFOCTR; + break; + + default: + buffer = 0; + break; + } + + if ((buffer & USB_FUNCTION_BITFRDY) == USB_FUNCTION_BITFRDY) + { + return buffer; + } + + loop2 = 25; + while (loop2-- > 0) + { + /* wait */ + } + } + + return DEVDRV_USBF_FIFOERROR; +} + +/******************************************************************************* +* Function Name: usb1_function_set_curpipe +* Description : Allocates FIF0 specified by the argument in the pipe assigned +* : by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* Return Value : none +*******************************************************************************/ +void usb1_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw) +{ + uint16_t buffer; + uint32_t loop; + volatile uint32_t loop2; + + g_usb1_function_mbw[pipe] = mbw; + + switch (fifosel) + { + case USB_FUNCTION_CUSE: + buffer = USB201.CFIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE); + buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL); + USB201.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(isel | pipe | mbw); + USB201.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D0DMA: + case USB_FUNCTION_D0USE: + buffer = USB201.D0FIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); + USB201.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB201.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D1DMA: + case USB_FUNCTION_D1USE: + buffer = USB201.D1FIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); + USB201.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB201.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == + (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + default: + break; + } + + /* Cautions !!! + * Depending on the external bus speed of CPU, you may need to wait for 450ns here. + * For details, please look at the data sheet. */ + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } +} + +/******************************************************************************* +* Function Name: usb1_function_set_curpipe2 +* Description : Allocates FIF0 specified by the argument in the pipe assigned +* : by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* : uint16_t dfacc ; DFACC Access mode +* Return Value : none +*******************************************************************************/ +void usb1_function_set_curpipe2 (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc) +{ + uint16_t buffer; + uint32_t loop; +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + uint32_t dummy; +#endif + volatile uint32_t loop2; + + g_usb1_function_mbw[pipe] = mbw; + + switch (fifosel) + { + case USB_FUNCTION_CUSE: + buffer = USB201.CFIFOSEL; + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE); + buffer |= (uint16_t)(~isel & USB_FUNCTION_BITISEL); + USB201.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + while (loop2-- > 0) + { + /* wait */ + } + } + buffer &= (uint16_t)~(USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(isel | pipe | mbw); + USB201.CFIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.CFIFOSEL & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE)) == + (buffer & (USB_FUNCTION_BITISEL | USB_FUNCTION_BITCURPIPE))) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D0DMA: + case USB_FUNCTION_D0USE: + buffer = USB201.D0FIFOSEL; +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + + if (dfacc != 0) + { + buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32); + } +#else + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); +#endif + USB201.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dfacc != 0) + { + dummy = USB201.D0FIFO.UINT32; + } +#endif + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB201.D0FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D0FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + case USB_FUNCTION_D1DMA: + case USB_FUNCTION_D1USE: + buffer = USB201.D1FIFOSEL; +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + + if (dfacc != 0) + { + buffer |= (uint16_t)(USB_FUNCTION_BITMBW_32); + } +#else + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE); +#endif + USB201.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } +#ifdef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dfacc != 0) + { + dummy = USB201.D1FIFO.UINT32; + loop = dummy; // avoid warning. + } +#endif + buffer &= (uint16_t)~(USB_FUNCTION_BITCURPIPE | USB_FUNCTION_BITMBW); + buffer |= (uint16_t)(pipe | mbw); + USB201.D1FIFOSEL = buffer; + + for (loop = 0; loop < 4; loop++) + { + if ((USB201.D1FIFOSEL & USB_FUNCTION_BITCURPIPE) == (buffer & USB_FUNCTION_BITCURPIPE)) + { + break; + } + + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } + } + break; + + default: + break; + } + + /* Cautions !!! + * Depending on the external bus speed of CPU, you may need to wait for 450ns here. + * For details, please look at the data sheet. */ + loop2 = 100; + + while (loop2-- > 0) + { + /* wait */ + } +} + +/******************************************************************************* +* Function Name: usb1_function_write_c_fifo +* Description : Writes data in CFIFO. +* : Writes data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating CFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb1_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb1_function_write_c_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + USB201.CFIFO.UINT8[HH] = *g_usb1_function_data_pointer[pipe]; + g_usb1_function_data_pointer[pipe] += 1; + } + } + else if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)(count / 2); even; --even) + { + USB201.CFIFO.UINT16[H] = *((uint16_t *)g_usb1_function_data_pointer[pipe]); + g_usb1_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)(count / 4); even; --even) + { + USB201.CFIFO.UINT32 = *((uint32_t *)g_usb1_function_data_pointer[pipe]); + g_usb1_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_read_c_fifo +* Description : Reads data from CFIFO. +* : Reads data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating CFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb1_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb1_function_read_c_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + *g_usb1_function_data_pointer[pipe] = USB201.CFIFO.UINT8[HH]; + g_usb1_function_data_pointer[pipe] += 1; + } + } + else if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)((count + 1) / 2); even; --even) + { + *((uint16_t *)g_usb1_function_data_pointer[pipe]) = USB201.CFIFO.UINT16[H]; + g_usb1_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)((count + 3) / 4); even; --even) + { + *((uint32_t *)g_usb1_function_data_pointer[pipe]) = USB201.CFIFO.UINT32; + g_usb1_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_write_d0_fifo +* Description : Writes data in D0FIFO. +* : Writes data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating CFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb1_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb1_function_write_d0_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + USB201.D0FIFO.UINT8[HH] = *g_usb1_function_data_pointer[pipe]; + g_usb1_function_data_pointer[pipe] += 1; + } + } + else if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)(count / 2); even; --even) + { + USB201.D0FIFO.UINT16[H] = *((uint16_t *)g_usb1_function_data_pointer[pipe]); + g_usb1_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)(count / 4); even; --even) + { + USB201.D0FIFO.UINT32 = *((uint32_t *)g_usb1_function_data_pointer[pipe]); + g_usb1_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_read_d0_fifo +* Description : Reads data from D0FIFO. +* : Reads data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating DOFIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb1_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb1_function_read_d0_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + *g_usb1_function_data_pointer[pipe] = USB201.D0FIFO.UINT8[HH]; + g_usb1_function_data_pointer[pipe] += 1; + } + } + else if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)((count + 1) / 2); even; --even) + { + *((uint16_t *)g_usb1_function_data_pointer[pipe]) = USB201.D0FIFO.UINT16[H]; + g_usb1_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)((count + 3) / 4); even; --even) + { + *((uint32_t *)g_usb1_function_data_pointer[pipe]) = USB201.D0FIFO.UINT32; + g_usb1_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_write_d1_fifo +* Description : Writes data in D1FIFO. +* : Writes data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating D1FIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb1_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb1_function_write_d1_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + USB201.D1FIFO.UINT8[HH] = *g_usb1_function_data_pointer[pipe]; + g_usb1_function_data_pointer[pipe] += 1; + } + } + else if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)(count / 2); even; --even) + { + USB201.D1FIFO.UINT16[H] = *((uint16_t *)g_usb1_function_data_pointer[pipe]); + g_usb1_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)(count / 4); even; --even) + { + USB201.D1FIFO.UINT32 = *((uint32_t *)g_usb1_function_data_pointer[pipe]); + g_usb1_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_read_d1_fifo +* Description : Reads data from D1FIFO. +* : Reads data by BYTE/WORD/LONG according to access size +* : to the pipe specified by the arguments. +* : Before executing this function, allocating D1FIF0 in the specified pipe +* : should be completed. +* : Before executing this function, access size to the specified pipe +* : should be fixed and set in g_usb1_function_mbw[]. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t count ; Data Size(Byte) +* Return Value : none +*******************************************************************************/ +static void usb1_function_read_d1_fifo (uint16_t pipe, uint16_t count) +{ + uint16_t even; + + if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_8) + { + for (even = count; even; --even) + { + *g_usb1_function_data_pointer[pipe] = USB201.D1FIFO.UINT8[HH]; + g_usb1_function_data_pointer[pipe] += 1; + } + } + else if (g_usb1_function_mbw[pipe] == USB_FUNCTION_BITMBW_16) + { + for (even = (uint16_t)((count + 1) / 2); even; --even) + { + *((uint16_t *)g_usb1_function_data_pointer[pipe]) = USB201.D1FIFO.UINT16[H]; + g_usb1_function_data_pointer[pipe] += 2; + } + } + else + { + for (even = (uint16_t)((count + 3) / 4); even; --even) + { + *((uint32_t *)g_usb1_function_data_pointer[pipe]) = USB201.D1FIFO.UINT32; + g_usb1_function_data_pointer[pipe] += 4; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_com_get_dmasize +* Description : Calculates access width of DMA transfer by the argument to +* : return as the Return Value. +* Arguments : uint32_t trncount : transfer byte +* : uint32_t dtptr : transfer data pointer +* Return Value : DMA transfer size : 0 8bit +* : : 1 16bit +* : : 2 32bit +*******************************************************************************/ +static uint32_t usb1_function_com_get_dmasize (uint32_t trncount, uint32_t dtptr) +{ + uint32_t size; + + if (((trncount & 0x0001) != 0) || ((dtptr & 0x00000001) != 0)) + { + /* When transfer byte count is odd */ + /* or transfer data area is 8-bit alignment */ + size = 0; /* 8bit */ + } + else if (((trncount & 0x0003) != 0) || ((dtptr & 0x00000003) != 0)) + { + /* When the transfer byte count is multiples of 2 */ + /* or the transfer data area is 16-bit alignment */ + size = 1; /* 16bit */ + } + else + { + /* When the transfer byte count is multiples of 4 */ + /* or the transfer data area is 32-bit alignment */ + size = 2; /* 32bit */ + } + + return size; +} + +/******************************************************************************* +* Function Name: usb1_function_get_mbw +* Description : Calculates access width of DMA to return the value set in MBW. +* Arguments : uint32_t trncount : transfer byte +* : uint32_t dtptr : transfer data pointer +* Return Value : FIFO transfer size : USB_FUNCTION_BITMBW_8 8bit +* : : USB_FUNCTION_BITMBW_16 16bit +* : : USB_FUNCTION_BITMBW_32 32bit +*******************************************************************************/ +uint16_t usb1_function_get_mbw (uint32_t trncount, uint32_t dtptr) +{ + uint32_t size; + uint16_t mbw; + + size = usb1_function_com_get_dmasize(trncount, dtptr); + + if (size == 0) + { + /* 8bit */ + mbw = USB_FUNCTION_BITMBW_8; + } + else if (size == 1) + { + /* 16bit */ + mbw = USB_FUNCTION_BITMBW_16; + } + else + { + /* 32bit */ + mbw = USB_FUNCTION_BITMBW_32; + } + + return mbw; +} + +/******************************************************************************* +* Function Name: usb1_function_set_transaction_counter +* Description : Sets transaction counter by the argument(PIPEnTRN). +* : Clears transaction before setting to enable transaction counter setting. +* Arguments : uint16_t pipe ; Pipe number +* : uint32_t bsize : Data transfer size +* Return Value : none +*******************************************************************************/ +static void usb1_function_set_transaction_counter (uint16_t pipe, uint32_t bsize) +{ + uint16_t mxps; + uint16_t cnt; + + if (bsize == 0) + { + return; + } + + mxps = usb1_function_get_mxps(pipe); /* Max Packet Size */ + + if ((bsize % mxps) == 0) + { + cnt = (uint16_t)(bsize / mxps); + } + else + { + cnt = (uint16_t)((bsize / mxps) + 1); + } + + switch (pipe) + { + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPE1TRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPE1TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPE2TRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPE2TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPE3TRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPE3TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPE4TRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPE4TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPE5TRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPE5TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPE9TRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPE9TRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEATRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPEATRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPEATRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPEBTRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPEBTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPECTRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPECTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPEDTRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPEDTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEETRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPEETRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPEETRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + USB201.PIPEFTRN = cnt; + RZA_IO_RegWrite_16(&USB201.PIPEFTRE, + 1, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_clear_transaction_counter +* Description : Clears the transaction counter by the argument. +* : After executing this function, the transaction counter is invalid. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb1_function_clear_transaction_counter (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPE1TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPE2TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPE3TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPE4TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPE5TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9TRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPE9TRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEATRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPEATRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPEBTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPECTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPEDTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEETRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPEETRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFTRE, + 0, + USB_PIPEnTRE_TRENB_SHIFT, + USB_PIPEnTRE_TRENB); + RZA_IO_RegWrite_16(&USB201.PIPEFTRE, + 1, + USB_PIPEnTRE_TRCLR_SHIFT, + USB_PIPEnTRE_TRCLR); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_stop_transfer +* Description : Stops the USB transfer in the pipe specified by the argument. +* : After stopping the USB transfer, clears the buffer allocated in +* : the pipe. +* : After executing this function, allocation in FIF0 becomes USB_FUNCTION_PIPE0; +* : invalid. After executing this function, BRDY/NRDY/BEMP interrupt +* : in the corresponding pipe becomes invalid. Sequence bit is also +* : cleared. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_stop_transfer (uint16_t pipe) +{ + uint16_t usefifo; + uint32_t remain; + uint16_t fifo; + + usb1_function_set_pid_nak(pipe); + + usefifo = (uint16_t)(g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + switch (usefifo) + { + case USB_FUNCTION_D0FIFO_USE: + usb1_function_clear_transaction_counter(pipe); + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D0USE; + break; + + case USB_FUNCTION_D1FIFO_USE: + usb1_function_clear_transaction_counter(pipe); + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D1USE; + break; + + case USB_FUNCTION_D0FIFO_DMA: + remain = Userdef_USB_usb1_function_stop_dma0(); + usb1_function_dma_stop_d0(pipe, remain); + usb1_function_clear_transaction_counter(pipe); + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D0DMA; + break; + + case USB_FUNCTION_D1FIFO_DMA: + remain = Userdef_USB_usb1_function_stop_dma1(); + usb1_function_dma_stop_d1(pipe, remain); + usb1_function_clear_transaction_counter(pipe); + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_D1DMA; + break; + + default: + usb1_function_clear_transaction_counter(pipe); + USB201.CFIFOCTR = USB_FUNCTION_BITBCLR; /* Buffer Clear */ + fifo = USB_FUNCTION_CUSE; + break; + } + + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, fifo, DEVDRV_USBF_NO, USB_FUNCTION_BITMBW_16); + + /* Interrupt of pipe set is disabled */ + usb1_function_disable_brdy_int(pipe); + usb1_function_disable_nrdy_int(pipe); + usb1_function_disable_bemp_int(pipe); + + usb1_function_aclrm(pipe); + usb1_function_set_csclr(pipe); + + if ( g_usb1_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT ) + { + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES; + } +} + +/******************************************************************************* +* Function Name: usb1_function_set_dfacc_d0 +* Description : Sets the DFACC setting value in D0FIFO using the transfer size. +* Arguments : uint16_t mbw ; MBW +* : uint16_t count ; data count +* Return Value : DFACC Access mode +*******************************************************************************/ +static uint16_t usb1_function_set_dfacc_d0 (uint16_t mbw, uint32_t count) +{ + uint16_t dfacc = 0; + +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; +#else + if (mbw == USB_FUNCTION_BITMBW_32) + { + if ((count % 32) == 0) + { + /* 32byte transfer */ + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 2, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 2; + } + else if ((count % 16) == 0) + { + /* 16byte transfer */ + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 1, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 1; + } + else + { + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + else + { + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D0FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } +#endif + return dfacc; +} + +/******************************************************************************* +* Function Name: usb1_function_set_dfacc_d1 +* Description : Set the DFACC setting value in D1FIFO using the transfer size. +* Arguments : uint16_t mbw ; MBW +* : uint16_t count ; data count +* Return Value : DFACC Access mode +*******************************************************************************/ +static uint16_t usb1_function_set_dfacc_d1 (uint16_t mbw, uint32_t count) +{ + uint16_t dfacc = 0; + +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; +#else + if (mbw == USB_FUNCTION_BITMBW_32) + { + if ((count % 32) == 0) + { + /* 32byte transfer */ + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 2, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 2; + } + else if ((count % 16) == 0) + { + /* 16byte transfer */ + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 1, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 1; + } + else + { + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + } + else if (mbw == USB_FUNCTION_BITMBW_16) + { + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } + else + { + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_DFACC_SHIFT, + USB_DnFBCFG_DFACC); + RZA_IO_RegWrite_16(&USB201.D1FBCFG, + 0, + USB_DnFBCFG_TENDE_SHIFT, + USB_DnFBCFG_TENDE); + dfacc = 0; + } +#endif + + return dfacc; +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dma.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dma.c new file mode 100644 index 000000000..c6f3f1472 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dma.c @@ -0,0 +1,346 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_dma.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +static void usb1_function_dmaint(uint16_t fifo); +static void usb1_function_dmaint_buf2fifo(uint16_t pipe); +static void usb1_function_dmaint_fifo2buf(uint16_t pipe); + + +/******************************************************************************* +* Function Name: usb1_function_dma_stop_d0 +* Description : D0FIFO DMA stop +* Arguments : uint16_t pipe : pipe number +* : uint32_t remain : transfer byte +* Return Value : none +*******************************************************************************/ +void usb1_function_dma_stop_d0 (uint16_t pipe, uint32_t remain) +{ + uint16_t dtln; + uint16_t dfacc; + uint16_t buffer; + uint16_t sds_b = 1; + + dfacc = RZA_IO_RegRead_16(&USB201.D0FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC); + + if (dfacc == 2) + { + sds_b = 32; + } + else if (dfacc == 1) + { + sds_b = 16; + } + else + { + if (g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 2) + { + sds_b = 4; + } + else if (g_usb1_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 1) + { + sds_b = 2; + } + else + { + sds_b = 1; + } + } + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + if (g_usb1_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE) + { + buffer = USB201.D0FIFOCTR; + dtln = (buffer & USB_FUNCTION_BITDTLN); + + if ((dtln % sds_b) != 0) + { + remain += (sds_b - (dtln % sds_b)); + } + g_usb1_function_PipeDataSize[pipe] = (g_usb1_function_data_count[pipe] - remain); + g_usb1_function_data_count[pipe] = remain; + } + } + + RZA_IO_RegWrite_16(&USB201.D0FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); +} + +/******************************************************************************* +* Function Name: usb1_function_dma_stop_d1 +* Description : D1FIFO DMA stop +* Arguments : uint16_t pipe : pipe number +* : uint32_t remain : transfer byte +* Return Value : none +*******************************************************************************/ +void usb1_function_dma_stop_d1 (uint16_t pipe, uint32_t remain) +{ + uint16_t dtln; + uint16_t dfacc; + uint16_t buffer; + uint16_t sds_b = 1; + + dfacc = RZA_IO_RegRead_16(&USB201.D1FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC); + + if (dfacc == 2) + { + sds_b = 32; + } + else if (dfacc == 1) + { + sds_b = 16; + } + else + { + if (g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 2) + { + sds_b = 4; + } + else if (g_usb1_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 1) + { + sds_b = 2; + } + else + { + sds_b = 1; + } + } + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1) + { + if (g_usb1_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE) + { + buffer = USB201.D1FIFOCTR; + dtln = (buffer & USB_FUNCTION_BITDTLN); + + if ((dtln % sds_b) != 0) + { + remain += (sds_b - (dtln % sds_b)); + } + g_usb1_function_PipeDataSize[pipe] = (g_usb1_function_data_count[pipe] - remain); + g_usb1_function_data_count[pipe] = remain; + } + } + + RZA_IO_RegWrite_16(&USB201.D1FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE); +} + +/******************************************************************************* +* Function Name: usb1_function_dma_interrupt_d0fifo +* Description : This function is DMA interrupt handler entry. +* : Execute usb1_function_dmaint() after disabling DMA interrupt in this function. +* : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D0FIFO_DMA is +* : specified by dma->fifo. +* : Register this function as DMA complete interrupt. +* Arguments : uint32_t int_sense ; Interrupts detection mode +* : ; INTC_LEVEL_SENSITIVE : Level sense +* : ; INTC_EDGE_TRIGGER : Edge trigger +* Return Value : none +*******************************************************************************/ +void usb1_function_dma_interrupt_d0fifo (uint32_t int_sense) +{ + usb1_function_dmaint(USB_FUNCTION_D0FIFO); + g_usb1_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY; +} + +/******************************************************************************* +* Function Name: usb1_function_dma_interrupt_d1fifo +* Description : This function is DMA interrupt handler entry. +* : Execute usb1_function_dmaint() after disabling DMA interrupt in this function. +* : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D1FIFO_DMA is +* : specified by dma->fifo. +* : Register this function as DMA complete interrupt. +* Arguments : uint32_t int_sense ; Interrupts detection mode +* : ; INTC_LEVEL_SENSITIVE : Level sense +* : ; INTC_EDGE_TRIGGER : Edge trigger +* Return Value : none +*******************************************************************************/ +void usb1_function_dma_interrupt_d1fifo (uint32_t int_sense) +{ + usb1_function_dmaint(USB_FUNCTION_D1FIFO); + g_usb1_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY; +} + +/******************************************************************************* +* Function Name: usb1_function_dmaint +* Description : This function is DMA transfer end interrupt +* Arguments : uint16_t fifo ; fifo number +* : ; USB_FUNCTION_D0FIFO +* : ; USB_FUNCTION_D1FIFO +* Return Value : none +*******************************************************************************/ +static void usb1_function_dmaint (uint16_t fifo) +{ + uint16_t pipe; + + pipe = g_usb1_function_DmaPipe[fifo]; + + if (g_usb1_function_DmaInfo[fifo].dir == USB_FUNCTION_BUF2FIFO) + { + usb1_function_dmaint_buf2fifo(pipe); + } + else + { + usb1_function_dmaint_fifo2buf(pipe); + } +} + +/******************************************************************************* +* Function Name: usb1_function_dmaint_fifo2buf +* Description : Executes read completion from FIFO by DMAC. +* Arguments : uint16_t pipe : pipe number +* Return Value : none +*******************************************************************************/ +static void usb1_function_dmaint_fifo2buf (uint16_t pipe) +{ + uint32_t remain; + uint16_t useport; + + if (g_usb1_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE) + { + useport = (uint16_t)(g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + if (useport == USB_FUNCTION_D0FIFO_DMA) + { + remain = Userdef_USB_usb1_function_stop_dma0(); + usb1_function_dma_stop_d0(pipe, remain); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + if (g_usb1_function_DmaStatus[USB_FUNCTION_D0FIFO] == USB_FUNCTION_DMA_BUSYEND) + { + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + else + { + usb1_function_enable_brdy_int(pipe); + } + } + } + else + { + remain = Userdef_USB_usb1_function_stop_dma1(); + usb1_function_dma_stop_d1(pipe, remain); + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + if (g_usb1_function_DmaStatus[USB_FUNCTION_D1FIFO] == USB_FUNCTION_DMA_BUSYEND) + { + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + else + { + usb1_function_enable_brdy_int(pipe); + } + } + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_dmaint_buf2fifo +* Description : Executes write completion in FIFO by DMAC. +* Arguments : uint16_t pipe : pipe number +* Return Value : none +*******************************************************************************/ +static void usb1_function_dmaint_buf2fifo (uint16_t pipe) +{ + uint32_t remain; + uint16_t useport; + + useport = (uint16_t)(g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + + if (useport == USB_FUNCTION_D0FIFO_DMA) + { + remain = Userdef_USB_usb1_function_stop_dma0(); + usb1_function_dma_stop_d0(pipe, remain); + + if (g_usb1_function_DmaBval[USB_FUNCTION_D0FIFO] != 0) + { + RZA_IO_RegWrite_16(&USB201.D0FIFOCTR, + 1, + USB_DnFIFOCTR_BVAL_SHIFT, + USB_DnFIFOCTR_BVAL); + } + } + else + { + remain = Userdef_USB_usb1_function_stop_dma1(); + usb1_function_dma_stop_d1(pipe, remain); + + if (g_usb1_function_DmaBval[USB_FUNCTION_D1FIFO] != 0) + { + RZA_IO_RegWrite_16(&USB201.D1FIFOCTR, + 1, + USB_DnFIFOCTR_BVAL_SHIFT, + USB_DnFIFOCTR_BVAL); + } + } + + usb1_function_enable_bemp_int(pipe); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_intrn.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_intrn.c new file mode 100644 index 000000000..bdcc9a8f7 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_intrn.c @@ -0,0 +1,249 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_intrn.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb1_function_brdy_int +* Description : Executes BRDY interrupt(USB_FUNCTION_PIPE1-9). +* : According to the pipe that interrupt is generated in, +* : reads/writes buffer allocated in the pipe. +* : This function is executed in the BRDY interrupt handler. +* : This function clears BRDY interrupt status and BEMP interrupt +* : status. +* Arguments : uint16_t Status ; BRDYSTS Register Value +* : uint16_t Int_enbl ; BRDYENB Register Value +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_function_brdy_int (uint16_t status, uint16_t int_enb) +{ + uint32_t int_sense = 0; + uint16_t pipe; + uint16_t pipebit; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + pipebit = g_usb1_function_bit_set[pipe]; + + if ((status & pipebit) && (int_enb & pipebit)) + { + USB201.BRDYSTS = (uint16_t)~pipebit; + USB201.BEMPSTS = (uint16_t)~pipebit; + if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) + { + if (g_usb1_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY) + { + usb1_function_dma_interrupt_d0fifo(int_sense); + } + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + usb1_function_read_dma(pipe); + usb1_function_disable_brdy_int(pipe); + } + else + { + USB201.D0FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + } + else if ((g_usb1_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA) + { + if (g_usb1_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY) + { + usb1_function_dma_interrupt_d1fifo(int_sense); + } + + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) + { + usb1_function_read_dma(pipe); + usb1_function_disable_brdy_int(pipe); + } + else + { + USB201.D1FIFOCTR = USB_FUNCTION_BITBCLR; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + } + else + { + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) + { + usb1_function_read_buffer(pipe); + } + else + { + usb1_function_write_buffer(pipe); + } + } + } + } +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_nrdy_int +* Description : Executes NRDY interrupt(USB_FUNCTION_PIPE1-9). +* : Checks NRDY interrupt cause by PID. When the cause if STALL, +* : regards the pipe state as STALL and ends the processing. +* : Then the cause is not STALL, increments the error count to +* : communicate again. When the error count is 3, determines +* : the pipe state as DEVDRV_USBF_PIPE_NORES and ends the processing. +* : This function is executed in the NRDY interrupt handler. +* : This function clears NRDY interrupt status. +* Arguments : uint16_t status ; NRDYSTS Register Value +* : uint16_t int_enb ; NRDYENB Register Value +* Return Value : none +*******************************************************************************/ +void usb1_function_nrdy_int (uint16_t status, uint16_t int_enb) +{ + uint16_t pid; + uint16_t pipe; + uint16_t bitcheck; + + bitcheck = (uint16_t)(status & int_enb); + + USB201.NRDYSTS = (uint16_t)~status; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + if ((bitcheck&g_usb1_function_bit_set[pipe]) == g_usb1_function_bit_set[pipe]) + { + if (RZA_IO_RegRead_16(&USB201.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1) + { + if (g_usb1_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT) + { + pid = usb1_function_get_pid(pipe); + if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) + { + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; + } + else + { + g_usb1_function_PipeIgnore[pipe]++; + if (g_usb1_function_PipeIgnore[pipe] == 3) + { + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES; + } + else + { + usb1_function_set_pid_buf(pipe); + } + } + } + } + else + { + /* USB Function */ + } + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_bemp_int +* Description : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9). +* Arguments : uint16_t status ; BEMPSTS Register Value +* : uint16_t int_enb ; BEMPENB Register Value +* Return Value : none +*******************************************************************************/ +void usb1_function_bemp_int (uint16_t status, uint16_t int_enb) +{ + uint16_t pid; + uint16_t pipe; + uint16_t bitcheck; + uint16_t inbuf; + + bitcheck = (uint16_t)(status & int_enb); + + USB201.BEMPSTS = (uint16_t)~status; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + if ((bitcheck&g_usb1_function_bit_set[pipe]) == g_usb1_function_bit_set[pipe]) + { + pid = usb1_function_get_pid(pipe); + + if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) + { + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; + } + else + { + inbuf = usb1_function_get_inbuf(pipe); + + if (inbuf == 0) + { + usb1_function_disable_bemp_int(pipe); + usb1_function_set_pid_nak(pipe); + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + } + } + } +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_lib.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_lib.c new file mode 100644 index 000000000..d448dc599 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_lib.c @@ -0,0 +1,2044 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_lib.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb1_function_enable_brdy_int +* Description : Enables BRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling +* : BRDY. Enables BRDY interrupt in the pipe specified by the argument +* : in the disabled status. After enabling BRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_enable_brdy_int (uint16_t pipe) +{ + /* enable brdy interrupt */ + USB201.BRDYENB |= (uint16_t)g_usb1_function_bit_set[pipe]; +} + +/******************************************************************************* +* Function Name: usb1_function_disable_brdy_int +* Description : Disables BRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling +* : BRDY. Enables BRDY interrupt in the pipe specified by the argument +* : in the disabled status. After disabling BRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_disable_brdy_int (uint16_t pipe) +{ + /* disable brdy interrupt */ + USB201.BRDYENB &= (uint16_t)~(g_usb1_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb1_function_clear_brdy_sts +* Description : Clear BRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_clear_brdy_sts (uint16_t pipe) +{ + /* clear brdy status */ + USB201.BRDYSTS = (uint16_t)~(g_usb1_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb1_function_enable_bemp_int +* Description : Enables BEMP interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling +* : BEMP. Enables BEMP interrupt in the pipe specified by the argument +* : in the disabled status. After enabling BEMP, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_enable_bemp_int (uint16_t pipe) +{ + /* enable bemp interrupt */ + USB201.BEMPENB |= (uint16_t)g_usb1_function_bit_set[pipe]; +} + +/******************************************************************************* +* Function Name: usb1_function_disable_bemp_int +* Description : Disables BEMP interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling +* : BEMP. Enables BEMP interrupt in the pipe specified by the argument +* : in the disabled status. After enabling BEMP, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_disable_bemp_int (uint16_t pipe) +{ + /* disable bemp interrupt */ + USB201.BEMPENB &= (uint16_t)~(g_usb1_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb1_function_clear_bemp_sts +* Description : Clear BEMP interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_clear_bemp_sts (uint16_t pipe) +{ + /* clear bemp status */ + USB201.BEMPSTS = (uint16_t)~(g_usb1_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb1_function_enable_nrdy_int +* Description : Enables NRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before enabling +* : NRDY. Enables NRDY interrupt in the pipe specified by the argument +* : in the disabled status. After enabling NRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_enable_nrdy_int (uint16_t pipe) +{ + /* enable nrdy interrupt */ + USB201.NRDYENB |= (uint16_t)g_usb1_function_bit_set[pipe]; +} + +/******************************************************************************* +* Function Name: usb1_function_disable_nrdy_int +* Description : Disables NRDY interrupt in the pipe spceified by the argument. +* : Disables BEMP/NRDY/BRDY interrupts in all pipes before disabling +* : NRDY. Disables NRDY interrupt in the pipe specified by the argument +* : in the disabled status. After disabling NRDY, recover all +* : BEMP/NRDY/BRDY disabled/enabled status. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_disable_nrdy_int (uint16_t pipe) +{ + /* disable nrdy interrupt */ + USB201.NRDYENB &= (uint16_t)~(g_usb1_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb1_function_clear_nrdy_sts +* Description : Clear NRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_clear_nrdy_sts (uint16_t pipe) +{ + /* clear nrdy status */ + USB201.NRDYSTS = (uint16_t)~(g_usb1_function_bit_set[pipe]); +} + +/******************************************************************************* +* Function Name: usb1_function_is_hispeed +* Description : Returns the result of USB reset hand shake (RHST) as +* : return value. +* Arguments : none +* Return Value : USB_FUNCTION_HIGH_SPEED ; Hi-Speed +* : USB_FUNCTION_FULL_SPEED ; Full-Speed +* : LOW_SPEED ; Low-Speed +* : USB_FUNCTION_NON_SPEED ; error +*******************************************************************************/ +uint16_t usb1_function_is_hispeed (void) +{ + uint16_t rhst; + uint16_t speed; + + rhst = RZA_IO_RegRead_16(&USB201.DVSTCTR0, USB_DVSTCTR0_RHST_SHIFT, USB_DVSTCTR0_RHST); + + if (rhst == USB_FUNCTION_HSMODE) + { + speed = USB_FUNCTION_HIGH_SPEED; + } + else if (rhst == USB_FUNCTION_FSMODE) + { + speed = USB_FUNCTION_FULL_SPEED; + } + else if (rhst == USB_FUNCTION_LSMODE) + { + speed = USB_FUNCTION_LOW_SPEED; + } + else + { + speed = USB_FUNCTION_NON_SPEED; + } + + return speed; +} + +/******************************************************************************* +* Function Name: usb1_function_is_hispeed_enable +* Description : Returns the USB High-Speed connection enabled status as +* : return value. +* Arguments : none +* Return Value : DEVDRV_USBF_YES : Hi-Speed Enable +* : DEVDRV_USBF_NO : Hi-Speed Disable +*******************************************************************************/ +uint16_t usb1_function_is_hispeed_enable (void) +{ + uint16_t ret; + + ret = DEVDRV_USBF_NO; + + if (RZA_IO_RegRead_16(&USB201.SYSCFG0, USB_SYSCFG_HSE_SHIFT, USB_SYSCFG_HSE) == 1) + { + ret = DEVDRV_USBF_YES; + } + + return ret; +} + +/******************************************************************************* +* Function Name: usb1_function_set_pid_buf +* Description : Enables communicaqtion in the pipe specified by the argument +* : (BUF). +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_set_pid_buf (uint16_t pipe) +{ + uint16_t pid; + + pid = usb1_function_get_pid(pipe); + + if (pid == DEVDRV_USBF_PID_STALL2) + { + usb1_function_set_pid_nak(pipe); + } + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + DEVDRV_USBF_PID_BUF, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + DEVDRV_USBF_PID_BUF, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_set_pid_nak +* Description : Disables communication (NAK) in the pipe specified by the argument. +* : When the pipe status was enabling communication (BUF) before +* : executing before executing this function, waits in the software +* : until the pipe becomes ready after setting disabled. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_set_pid_nak (uint16_t pipe) +{ + uint16_t pid; + uint16_t pbusy; + uint32_t loop; + + pid = usb1_function_get_pid(pipe); + + if (pid == DEVDRV_USBF_PID_STALL2) + { + usb1_function_set_pid_stall(pipe); + } + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + DEVDRV_USBF_PID_NAK, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + DEVDRV_USBF_PID_NAK, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } + + if (pid == DEVDRV_USBF_PID_BUF) + { + for (loop = 0; loop < 200; loop++) + { + switch (pipe) + { + case USB_FUNCTION_PIPE0: + pbusy = RZA_IO_RegRead_16(&USB201.DCPCTR, + USB_DCPCTR_PBUSY_SHIFT, + USB_DCPCTR_PBUSY); + break; + + case USB_FUNCTION_PIPE1: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE1CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE2: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE2CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE3: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE3CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE4: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE4CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE5: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE5CTR, + USB_PIPEnCTR_1_5_PBUSY_SHIFT, + USB_PIPEnCTR_1_5_PBUSY); + break; + + case USB_FUNCTION_PIPE6: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE6CTR, + USB_PIPEnCTR_6_8_PBUSY_SHIFT, + USB_PIPEnCTR_6_8_PBUSY); + break; + + case USB_FUNCTION_PIPE7: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE7CTR, + USB_PIPEnCTR_6_8_PBUSY_SHIFT, + USB_PIPEnCTR_6_8_PBUSY); + break; + + case USB_FUNCTION_PIPE8: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE8CTR, + USB_PIPEnCTR_6_8_PBUSY_SHIFT, + USB_PIPEnCTR_6_8_PBUSY); + break; + + case USB_FUNCTION_PIPE9: + pbusy = RZA_IO_RegRead_16(&USB201.PIPE9CTR, + USB_PIPEnCTR_9_PBUSY_SHIFT, + USB_PIPEnCTR_9_PBUSY); + break; + + case USB_FUNCTION_PIPEA: + pbusy = RZA_IO_RegRead_16(&USB201.PIPEACTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEB: + pbusy = RZA_IO_RegRead_16(&USB201.PIPEBCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEC: + pbusy = RZA_IO_RegRead_16(&USB201.PIPECCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPED: + pbusy = RZA_IO_RegRead_16(&USB201.PIPEDCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEE: + pbusy = RZA_IO_RegRead_16(&USB201.PIPEECTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + case USB_FUNCTION_PIPEF: + pbusy = RZA_IO_RegRead_16(&USB201.PIPEFCTR, + USB_PIPEnCTR_A_F_PBUSY_SHIFT, + USB_PIPEnCTR_A_F_PBUSY); + break; + + default: + pbusy = 1; + break; + } + + if (pbusy == 0) + { + break; + } + Userdef_USB_usb1_function_delay_500ns(); + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_set_pid_stall +* Description : Disables communication (STALL) in the pipe specified by the +* : argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_set_pid_stall (uint16_t pipe) +{ + uint16_t pid; + + pid = usb1_function_get_pid(pipe); + if (pid == DEVDRV_USBF_PID_BUF) + { + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + DEVDRV_USBF_PID_STALL2, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + DEVDRV_USBF_PID_STALL2, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } + } + else + { + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + DEVDRV_USBF_PID_STALL, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + DEVDRV_USBF_PID_STALL, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + break; + } + } +} + +/******************************************************************************* +* Function Name: usb1_function_clear_pid_stall +* Description : Disables communication (NAK) in the pipe specified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_clear_pid_stall (uint16_t pipe) +{ + usb1_function_set_pid_nak(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_get_pid +* Description : Returns the pipe state specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : PID +*******************************************************************************/ +uint16_t usb1_function_get_pid (uint16_t pipe) +{ + uint16_t pid; + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + pid = RZA_IO_RegRead_16(&USB201.DCPCTR, + USB_DCPCTR_PID_SHIFT, + USB_DCPCTR_PID); + break; + + case USB_FUNCTION_PIPE1: + pid = RZA_IO_RegRead_16(&USB201.PIPE1CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE2: + pid = RZA_IO_RegRead_16(&USB201.PIPE2CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE3: + pid = RZA_IO_RegRead_16(&USB201.PIPE3CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE4: + pid = RZA_IO_RegRead_16(&USB201.PIPE4CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE5: + pid = RZA_IO_RegRead_16(&USB201.PIPE5CTR, + USB_PIPEnCTR_1_5_PID_SHIFT, + USB_PIPEnCTR_1_5_PID); + break; + + case USB_FUNCTION_PIPE6: + pid = RZA_IO_RegRead_16(&USB201.PIPE6CTR, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE7: + pid = RZA_IO_RegRead_16(&USB201.PIPE7CTR, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE8: + pid = RZA_IO_RegRead_16(&USB201.PIPE8CTR, + USB_PIPEnCTR_6_8_PID_SHIFT, + USB_PIPEnCTR_6_8_PID); + break; + + case USB_FUNCTION_PIPE9: + pid = RZA_IO_RegRead_16(&USB201.PIPE9CTR, + USB_PIPEnCTR_9_PID_SHIFT, + USB_PIPEnCTR_9_PID); + break; + + case USB_FUNCTION_PIPEA: + pid = RZA_IO_RegRead_16(&USB201.PIPEACTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEB: + pid = RZA_IO_RegRead_16(&USB201.PIPEBCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEC: + pid = RZA_IO_RegRead_16(&USB201.PIPECCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPED: + pid = RZA_IO_RegRead_16(&USB201.PIPEDCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEE: + pid = RZA_IO_RegRead_16(&USB201.PIPEECTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + case USB_FUNCTION_PIPEF: + pid = RZA_IO_RegRead_16(&USB201.PIPEFCTR, + USB_PIPEnCTR_A_F_PID_SHIFT, + USB_PIPEnCTR_A_F_PID); + break; + + default: + pid = 0; + break; + } + + return pid; +} + +/******************************************************************************* +* Function Name: usb1_function_set_csclr +* Description : CSPLIT status clear setting of sprit transaction in specified +* : pipe is performed. +* : When SQSET bit or SQCLR bit, and SQSET bit or SQCLR bit +* : in DCPCTR register are continuously changed (when the sequence +* : toggle bit of data PID is continuously changed over two or more pipes), +* : the access cycle with 120 ns and more than 5 cycle bus clock is necessary. +* : Do not set both SQCLR bit and SQSET bit to 1 at the same time. +* : In addition, both bits should be operated after PID is set to NAK. +* : However, when it is set to the isochronous transfer as the transfer type +* : (TYPE=11), writing in SQSET bit is disabled. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb1_function_set_csclr (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + 1, + USB_DCPCTR_CSCLR_SHIFT, + USB_DCPCTR_CSCLR); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_CSCLR_SHIFT, + USB_PIPEnCTR_1_5_CSCLR); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_CSCLR_SHIFT, + USB_PIPEnCTR_6_8_CSCLR); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_CSCLR_SHIFT, + USB_PIPEnCTR_6_8_CSCLR); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_CSCLR_SHIFT, + USB_PIPEnCTR_6_8_CSCLR); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + 1, + USB_PIPEnCTR_9_CSCLR_SHIFT, + USB_PIPEnCTR_9_CSCLR); + break; + + default: + /* PIPEA-F have not CSCLR */ + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_set_sqclr +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA0. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_function_set_sqclr (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + 1, + USB_DCPCTR_SQCLR_SHIFT, + USB_DCPCTR_SQCLR); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_SQCLR_SHIFT, + USB_PIPEnCTR_1_5_SQCLR); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_SQCLR_SHIFT, + USB_PIPEnCTR_6_8_SQCLR); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_SQCLR_SHIFT, + USB_PIPEnCTR_6_8_SQCLR); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_SQCLR_SHIFT, + USB_PIPEnCTR_6_8_SQCLR); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + 1, + USB_PIPEnCTR_9_SQCLR_SHIFT, + USB_PIPEnCTR_9_SQCLR); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + 1, + USB_PIPEnCTR_A_F_SQCLR_SHIFT, + USB_PIPEnCTR_A_F_SQCLR); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_set_sqset +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA1. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb1_function_set_sqset (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + RZA_IO_RegWrite_16(&USB201.DCPCTR, + 1, + USB_DCPCTR_SQSET_SHIFT, + USB_DCPCTR_SQSET); + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_SQSET_SHIFT, + USB_PIPEnCTR_1_5_SQSET); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_SQSET_SHIFT, + USB_PIPEnCTR_6_8_SQSET); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_SQSET_SHIFT, + USB_PIPEnCTR_6_8_SQSET); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_SQSET_SHIFT, + USB_PIPEnCTR_6_8_SQSET); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + 1, + USB_PIPEnCTR_9_SQSET_SHIFT, + USB_PIPEnCTR_9_SQSET); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + 1, + USB_PIPEnCTR_A_F_SQSET_SHIFT, + USB_PIPEnCTR_A_F_SQSET); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_get_sqmon +* Description : Toggle bit of specified pipe is obtained +* Arguments : uint16_t pipe ; Pipe number +* Return Value : sqmon +*******************************************************************************/ +uint16_t usb1_function_get_sqmon (uint16_t pipe) +{ + uint16_t sqmon; + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + sqmon = RZA_IO_RegRead_16(&USB201.DCPCTR, + USB_DCPCTR_SQMON_SHIFT, + USB_DCPCTR_SQMON); + break; + + case USB_FUNCTION_PIPE1: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE1CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE2: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE2CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE3: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE3CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE4: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE4CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE5: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE5CTR, + USB_PIPEnCTR_1_5_SQMON_SHIFT, + USB_PIPEnCTR_1_5_SQMON); + break; + + case USB_FUNCTION_PIPE6: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE6CTR, + USB_PIPEnCTR_6_8_SQMON_SHIFT, + USB_PIPEnCTR_6_8_SQMON); + break; + + case USB_FUNCTION_PIPE7: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE7CTR, + USB_PIPEnCTR_6_8_SQMON_SHIFT, + USB_PIPEnCTR_6_8_SQMON); + break; + + case USB_FUNCTION_PIPE8: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE8CTR, + USB_PIPEnCTR_6_8_SQMON_SHIFT, + USB_PIPEnCTR_6_8_SQMON); + break; + + case USB_FUNCTION_PIPE9: + sqmon = RZA_IO_RegRead_16(&USB201.PIPE9CTR, + USB_PIPEnCTR_9_SQMON_SHIFT, + USB_PIPEnCTR_9_SQMON); + break; + + case USB_FUNCTION_PIPEA: + sqmon = RZA_IO_RegRead_16(&USB201.PIPEACTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEB: + sqmon = RZA_IO_RegRead_16(&USB201.PIPEBCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEC: + sqmon = RZA_IO_RegRead_16(&USB201.PIPECCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPED: + sqmon = RZA_IO_RegRead_16(&USB201.PIPEDCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEE: + sqmon = RZA_IO_RegRead_16(&USB201.PIPEECTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + case USB_FUNCTION_PIPEF: + sqmon = RZA_IO_RegRead_16(&USB201.PIPEFCTR, + USB_PIPEnCTR_A_F_SQMON_SHIFT, + USB_PIPEnCTR_A_F_SQMON); + break; + + default: + sqmon = 0; + break; + } + + return sqmon; +} + +/******************************************************************************* +* Function Name: usb1_function_aclrm +* Description : The buffer of specified pipe is initialized +* Arguments : uint16_t pipe : Pipe +* Return Value : none +*******************************************************************************/ +void usb1_function_aclrm (uint16_t pipe) +{ + usb1_function_set_aclrm(pipe); + usb1_function_clr_aclrm(pipe); +} + +/******************************************************************************* +* Function Name: usb1_function_set_aclrm +* Description : The auto buffer clear mode of specified pipe is enabled +* Arguments : uint16_t pipe : Pipe +* Return Value : none +*******************************************************************************/ +void usb1_function_set_aclrm (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + 1, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + 1, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + 1, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + 1, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + 1, + USB_PIPEnCTR_9_ACLRM_SHIFT, + USB_PIPEnCTR_9_ACLRM); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + 1, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_clr_aclrm +* Description : The auto buffer clear mode of specified pipe is enabled +* Arguments : uint16_t pipe : Pipe +* Return Value : none +*******************************************************************************/ +void usb1_function_clr_aclrm (uint16_t pipe) +{ + switch (pipe) + { + case USB_FUNCTION_PIPE0: + break; + + case USB_FUNCTION_PIPE1: + RZA_IO_RegWrite_16(&USB201.PIPE1CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE2: + RZA_IO_RegWrite_16(&USB201.PIPE2CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE3: + RZA_IO_RegWrite_16(&USB201.PIPE3CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE4: + RZA_IO_RegWrite_16(&USB201.PIPE4CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE5: + RZA_IO_RegWrite_16(&USB201.PIPE5CTR, + 0, + USB_PIPEnCTR_1_5_ACLRM_SHIFT, + USB_PIPEnCTR_1_5_ACLRM); + break; + + case USB_FUNCTION_PIPE6: + RZA_IO_RegWrite_16(&USB201.PIPE6CTR, + 0, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE7: + RZA_IO_RegWrite_16(&USB201.PIPE7CTR, + 0, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE8: + RZA_IO_RegWrite_16(&USB201.PIPE8CTR, + 0, + USB_PIPEnCTR_6_8_ACLRM_SHIFT, + USB_PIPEnCTR_6_8_ACLRM); + break; + + case USB_FUNCTION_PIPE9: + RZA_IO_RegWrite_16(&USB201.PIPE9CTR, + 0, + USB_PIPEnCTR_9_ACLRM_SHIFT, + USB_PIPEnCTR_9_ACLRM); + break; + + case USB_FUNCTION_PIPEA: + RZA_IO_RegWrite_16(&USB201.PIPEACTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEB: + RZA_IO_RegWrite_16(&USB201.PIPEBCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEC: + RZA_IO_RegWrite_16(&USB201.PIPECCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPED: + RZA_IO_RegWrite_16(&USB201.PIPEDCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEE: + RZA_IO_RegWrite_16(&USB201.PIPEECTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + case USB_FUNCTION_PIPEF: + RZA_IO_RegWrite_16(&USB201.PIPEFCTR, + 0, + USB_PIPEnCTR_A_F_ACLRM_SHIFT, + USB_PIPEnCTR_A_F_ACLRM); + break; + + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_get_inbuf +* Description : Returns INBUFM of the pipe specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : inbuf +*******************************************************************************/ +uint16_t usb1_function_get_inbuf (uint16_t pipe) +{ + uint16_t inbuf; + + switch (pipe) + { + case USB_FUNCTION_PIPE0: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE1: + inbuf = RZA_IO_RegRead_16(&USB201.PIPE1CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE2: + inbuf = RZA_IO_RegRead_16(&USB201.PIPE2CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE3: + inbuf = RZA_IO_RegRead_16(&USB201.PIPE3CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE4: + inbuf = RZA_IO_RegRead_16(&USB201.PIPE4CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE5: + inbuf = RZA_IO_RegRead_16(&USB201.PIPE5CTR, + USB_PIPEnCTR_1_5_INBUFM_SHIFT, + USB_PIPEnCTR_1_5_INBUFM); + break; + + case USB_FUNCTION_PIPE6: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE7: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE8: + inbuf = 0; + break; + + case USB_FUNCTION_PIPE9: + inbuf = RZA_IO_RegRead_16(&USB201.PIPE9CTR, + USB_PIPEnCTR_9_INBUFM_SHIFT, + USB_PIPEnCTR_9_INBUFM); + break; + + case USB_FUNCTION_PIPEA: + inbuf = RZA_IO_RegRead_16(&USB201.PIPEACTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEB: + inbuf = RZA_IO_RegRead_16(&USB201.PIPEBCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEC: + inbuf = RZA_IO_RegRead_16(&USB201.PIPECCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPED: + inbuf = RZA_IO_RegRead_16(&USB201.PIPEDCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEE: + inbuf = RZA_IO_RegRead_16(&USB201.PIPEECTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + case USB_FUNCTION_PIPEF: + inbuf = RZA_IO_RegRead_16(&USB201.PIPEFCTR, + USB_PIPEnCTR_A_F_INBUFM_SHIFT, + USB_PIPEnCTR_A_F_INBUFM); + break; + + default: + inbuf = 0; + break; + } + + return inbuf; +} + +/******************************************************************************* +* Function Name: usb1_function_setting_interrupt +* Description : Sets the USB module interrupt level. +* Arguments : uint8_t level +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_function_setting_interrupt (uint8_t level) +{ + uint16_t d0fifo_dmaintid; + uint16_t d1fifo_dmaintid; + + R_INTC_RegistIntFunc(INTC_ID_USBI1, usb1_function_interrupt); + R_INTC_SetPriority(INTC_ID_USBI1, level); + R_INTC_Enable(INTC_ID_USBI1); + + d0fifo_dmaintid = Userdef_USB_usb1_function_d0fifo_dmaintid(); + + if (d0fifo_dmaintid != 0xFFFF) + { + R_INTC_RegistIntFunc(d0fifo_dmaintid, usb1_function_dma_interrupt_d0fifo); + R_INTC_SetPriority(d0fifo_dmaintid, level); + R_INTC_Enable(d0fifo_dmaintid); + } + + d1fifo_dmaintid = Userdef_USB_usb1_function_d1fifo_dmaintid(); + + if (d1fifo_dmaintid != 0xFFFF) + { + R_INTC_RegistIntFunc(d1fifo_dmaintid, usb1_function_dma_interrupt_d1fifo); + R_INTC_SetPriority(d1fifo_dmaintid, level); + R_INTC_Enable(d1fifo_dmaintid); + } +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_reset_module +* Description : Initializes the USB module. +* : Enables providing clock to the USB module. +* : Sets USB bus wait register. +* Arguments : uint16_t clockmode ; 48MHz ; USBFCLOCK_X1_48MHZ +* : ; 12MHz ; USBFCLOCK_EXTAL_12MHZ +* Return Value : none +*******************************************************************************/ +void usb1_function_reset_module (uint16_t clockmode) +{ + /* UPLLE bit is only USB0 */ + if (RZA_IO_RegRead_16(&USB200.SYSCFG0, + USB_SYSCFG_UPLLE_SHIFT, + USB_SYSCFG_UPLLE) == 1) + { + if ((USB200.SYSCFG0 & USB_FUNCTION_BITUCKSEL) != clockmode) + { + RZA_IO_RegWrite_16(&USB201.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + USB201.SYSCFG0 = 0; + USB200.SYSCFG0 = 0; + USB200.SYSCFG0 = (USB_FUNCTION_BITUPLLE | clockmode); + Userdef_USB_usb1_function_delay_xms(1); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + RZA_IO_RegWrite_16(&USB201.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + } + else + { + RZA_IO_RegWrite_16(&USB201.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + Userdef_USB_usb1_function_delay_xms(1); + RZA_IO_RegWrite_16(&USB201.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + } + } + else + { + RZA_IO_RegWrite_16(&USB201.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 0, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + USB201.SYSCFG0 = 0; + USB200.SYSCFG0 = 0; + USB200.SYSCFG0 = (USB_FUNCTION_BITUPLLE | clockmode); + Userdef_USB_usb1_function_delay_xms(1); + RZA_IO_RegWrite_16(&USB200.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + RZA_IO_RegWrite_16(&USB201.SUSPMODE, + 1, + USB_SUSPMODE_SUSPM_SHIFT, + USB_SUSPMODE_SUSPM); + } + + USB201.BUSWAIT = (uint16_t)(USB_FUNCTION_BUSWAIT_05 & USB_FUNCTION_BITBWAIT); +} + +/******************************************************************************* +* Function Name: usb1_function_get_buf_size +* Description : Obtains pipe buffer size specified by the argument and +* : maximum packet size of the USB device in use. +* : When USB_FUNCTION_PIPE0 is specified by the argument, obtains the maximum +* : packet size of the USB device using the corresponding pipe. +* : For the case that USB_FUNCTION_PIPE0 is not assigned by the argument, when the +* : corresponding pipe is in continuous transfer mode, +* : obtains the buffer size allocated in the corresponcing pipe, +* : when incontinuous transfer, obtains maximum packet size. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : Maximum packet size or buffer size +*******************************************************************************/ +uint16_t usb1_function_get_buf_size (uint16_t pipe) +{ + uint16_t size; + uint16_t bufsize; + + if (pipe == USB_FUNCTION_PIPE0) + { + size = RZA_IO_RegRead_16(&USB201.DCPMAXP, + USB_DCPMAXP_MXPS_SHIFT, + USB_DCPMAXP_MXPS); + } + else + { + if (RZA_IO_RegRead_16(&g_usb1_function_pipecfg[pipe], USB_PIPECFG_CNTMD_SHIFT, USB_PIPECFG_CNTMD) == 1) + { + bufsize = RZA_IO_RegRead_16(&g_usb1_function_pipebuf[pipe], USB_PIPEBUF_BUFSIZE_SHIFT, USB_PIPEBUF_BUFSIZE); + size = (uint16_t)((bufsize + 1) * USB_FUNCTION_PIPExBUF); + } + else + { + size = RZA_IO_RegRead_16(&g_usb1_function_pipemaxp[pipe], USB_PIPEMAXP_MXPS_SHIFT, USB_PIPEMAXP_MXPS); + } + } + return size; +} + +/******************************************************************************* +* Function Name: usb1_function_get_mxps +* Description : Obtains maximum packet size of the USB device using the pipe +* : specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : Max Packet Size +*******************************************************************************/ +uint16_t usb1_function_get_mxps (uint16_t pipe) +{ + uint16_t size; + + if (pipe == USB_FUNCTION_PIPE0) + { + size = RZA_IO_RegRead_16(&USB201.DCPMAXP, + USB_DCPMAXP_MXPS_SHIFT, + USB_DCPMAXP_MXPS); + } + else + { + size = RZA_IO_RegRead_16(&g_usb1_function_pipemaxp[pipe], USB_PIPEMAXP_MXPS_SHIFT, USB_PIPEMAXP_MXPS); + } + return size; +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_api.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_api.c new file mode 100644 index 000000000..6edb9d2bf --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_api.c @@ -0,0 +1,441 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_api.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" +#include "dev_drv.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb1_api_function_init +* Description : Initializes the USB module in the USB function mode. +* Arguments : uint8_t int_level ; interruput level +* : uint16_t mode : Speed modes +* : : USB_FUCNTION_HIGH_SPEED: High-speed device +* : : USB_FUCNTION_FULL_SPEED: Full-speed device +* : uint16_t clockmode ; 48MHz ; USBFCLOCK_X1_48MHZ +* : ; 12MHz ; USBFCLOCK_EXTAL_12MHZ +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_api_function_init (uint8_t int_level, uint16_t mode, uint16_t clockmode) +{ + volatile uint8_t dummy_buf; + + CPG.STBCR7 &= 0xfc; /*The clock of USB0/1 modules is permitted */ + dummy_buf = CPG.STBCR7; /* (Dummy read) */ + + usb1_function_setting_interrupt(int_level); + + usb1_function_reset_module(clockmode); /* reset USB module with setting tranciever */ + /* and HSE=1 */ + + usb1_function_init_status(); /* clear variables */ + + usb1_function_InitModule(mode); /* select USB Function and Interrupt Enable */ + /* Detect USB Device to attach or detach */ +} +#endif + +/******************************************************************************* +* Function Name: usb1_api_function_IsConfigured +* Description : Checks if the USB device is configured to return the result as +* : the return value. +* Arguments : none +* Return Value : DEVDRV_USBF_YES : Configured & Configured Suspend +* : DEVDRV_USBF_NO : not Configured +*******************************************************************************/ +uint16_t usb1_api_function_IsConfigured (void) +{ + uint16_t dvst; + + dvst = usb1_function_GetDeviceState(); + + if ((dvst == USB_FUNCTION_DVST_CONFIGURED) || + (dvst == USB_FUNCTION_DVST_CONFIGURED_SUSPEND)) + { + return DEVDRV_USBF_YES; + } + + return DEVDRV_USBF_NO; +} + +/******************************************************************************* +* Function Name: usb1_function_GetDeviceState +* Description : Returns the state of USB device. +* Arguments : none +* Return Value : Device States +*******************************************************************************/ +uint16_t usb1_function_GetDeviceState (void) +{ + uint16_t dvsq; + uint16_t dvst; + + dvsq = USB201.INTSTS0; + switch (dvsq & USB_FUNCTION_BITDVSQ) + { + case USB_FUNCTION_DS_POWR: /* Power state *//* power-on */ + dvst = USB_FUNCTION_DVST_POWERED; + break; + + case USB_FUNCTION_DS_DFLT: /* Default state *//* bus-reset */ + dvst = USB_FUNCTION_DVST_DEFAULT; + break; + + case USB_FUNCTION_DS_ADDS: /* Address state */ + dvst = USB_FUNCTION_DVST_ADDRESS; + break; + + case USB_FUNCTION_DS_CNFG: /* Configured state */ + dvst = USB_FUNCTION_DVST_CONFIGURED; + break; + + case USB_FUNCTION_DS_SPD_CNFG: /* Configured Suspend state */ + dvst = USB_FUNCTION_DVST_CONFIGURED_SUSPEND; + break; + + case USB_FUNCTION_DS_SPD_POWR: /* Power Suspend state */ + case USB_FUNCTION_DS_SPD_DFLT: /* Default Suspend state */ + case USB_FUNCTION_DS_SPD_ADDR: /* Address Suspend state */ + dvst = USB_FUNCTION_DVST_SUSPEND; + break; + + default: /* error */ + dvst = USB_FUNCTION_DVST_SUSPEND; + break; + } + + return dvst; +} + +/******************************************************************************* +* Function Name: usb1_api_function_start_receive_transfer +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data data Address +* Return Value : none +*******************************************************************************/ +void usb1_api_function_start_receive_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + usb1_function_start_receive_transfer(pipe, size, data); +} + +/******************************************************************************* +* Function Name: usb1_api_function_start_send_transfer +* Description : Starts the USB data communication using pipe specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t size ; Data Size +* : uint8_t *data ; Data data Address +* Return Value : DEVDRV_USBF_WRITEEND ; Write end +* : DEVDRV_USBF_WRITESHRT ; short data +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_WRITEDMA ; Write DMA +* : DEVDRV_USBF_FIFOERROR ; FIFO status +*******************************************************************************/ +uint16_t usb1_api_function_start_send_transfer (uint16_t pipe, uint32_t size, uint8_t * data) +{ + uint16_t status; + + status = usb1_function_start_send_transfer(pipe, size, data); + + return status; +} + +/******************************************************************************* +* Function Name: usb1_api_function_check_pipe_status +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* : uint32_t *size ; Data Size +* Return Value : Pipe Status +*******************************************************************************/ +uint16_t usb1_api_function_check_pipe_status (uint16_t pipe, uint32_t * size) +{ + if (g_usb1_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_DONE) + { + *size = g_usb1_function_PipeDataSize[pipe]; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_PIPE_DONE; + } + else if (g_usb1_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_NORES) + { + *size = 0; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_PIPE_NORES; + } + else if (g_usb1_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_STALL) + { + *size = 0; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_PIPE_STALL; + } + else if (g_usb1_function_pipe_status[pipe] == DEVDRV_USBF_FIFOERROR) + { + *size = 0; + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + + return DEVDRV_USBF_FIFOERROR; + } + else + { + /* Do Nothing */ + } + + return g_usb1_function_pipe_status[pipe]; +} + +/******************************************************************************* +* Function Name: usb1_api_function_clear_pipe_status +* Description : Starts USB data reception using the pipe specified in the argument. +* : The FIFO for using is set in the pipe definition table. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : Pipe Status +*******************************************************************************/ +void usb1_api_function_clear_pipe_status (uint16_t pipe) +{ + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usb1_function_PipeDataSize[pipe] = 0; +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_pid_buf +* Description : Enables communicaqtion in the pipe specified by the argument +* : (BUF). +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_pid_buf (uint16_t pipe) +{ + usb1_function_set_pid_buf(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_pid_nak +* Description : Disables communication (NAK) in the pipe specified by the argument. +* : When the pipe status was enabling communication (BUF) before +* : executing before executing this function, waits in the software +* : until the pipe becomes ready after setting disabled. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_pid_nak (uint16_t pipe) +{ + usb1_function_set_pid_nak(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_pid_stall +* Description : Disables communication (STALL) in the pipe specified by the +* : argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_pid_stall (uint16_t pipe) +{ + usb1_function_set_pid_stall(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_clear_pid_stall +* Description : Disables communication (NAK) in the pipe specified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_clear_pid_stall (uint16_t pipe) +{ + usb1_function_clear_pid_stall(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_get_pid +* Description : Returns the pipe state specified by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : PID +*******************************************************************************/ +uint16_t usb1_api_function_get_pid (uint16_t pipe) +{ + uint16_t pid; + + pid = usb1_function_get_pid(pipe); + + return pid; +} + +/******************************************************************************* +* Function Name: usb1_api_function_check_stall +* Description : +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : PID +*******************************************************************************/ +int32_t usb1_api_function_check_stall (uint16_t pipe) +{ + uint16_t pid; + + pid = usb1_function_get_pid(pipe); + + if ((pid & DEVDRV_USBF_PID_STALL) == DEVDRV_USBF_PID_STALL) + { + return DEVDRV_USBF_STALL; + } + + return DEVDRV_SUCCESS; +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_sqclr +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA0. +* Arguments : uint16_t pipe ; Pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_sqclr (uint16_t pipe) +{ + usb1_function_set_sqclr(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_sqset +* Description : Sets the sequence bit of the pipe specified by the argument to +* : DATA1. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_sqset (uint16_t pipe) +{ + usb1_function_set_sqset(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_csclr +* Description : CSPLIT status clear setting of sprit transaction in specified +* : pipe is performed. +* : When SQSET bit or SQCLR bit, and SQSET bit or SQCLR bit +* : in DCPCTR register are continuously changed (when the sequence +* : toggle bit of data PID is continuously changed over two or more pipes), +* : the access cycle with 120 ns and more than 5 cycle bus clock is necessary. +* : Do not set both SQCLR bit and SQSET bit to 1 at the same time. +* : In addition, both bits should be operated after PID is set to NAK. +* : However, when it is set to the isochronous transfer as the transfer type +* : (TYPE=11), writing in SQSET bit is disabled. +* Arguments : uint16_t pipe ; Pipe number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_csclr (uint16_t pipe) +{ + usb1_function_set_csclr(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_set_curpipe +* Description : Allocates FIF0 specifed by the argument in the pipe assigned +* : by the argument. +* Arguments : uint16_t pipe ; Pipe Number +* : uint16_t fifosel ; Select FIFO +* : uint16_t isel ; FIFO Access Direction +* : uint16_t mbw ; FIFO Port Access Bit Width +* Return Value : none +*******************************************************************************/ +void usb1_api_function_set_curpipe (uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw) +{ + usb1_function_set_curpipe(pipe, fifosel, isel, mbw); +} + +/******************************************************************************* +* Function Name: usb1_api_function_clear_brdy_sts +* Description : Clear BRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_clear_brdy_sts (uint16_t pipe) +{ + usb1_function_clear_brdy_sts(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_clear_bemp_sts +* Description : Clear BEMP interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_clear_bemp_sts (uint16_t pipe) +{ + usb1_function_clear_bemp_sts(pipe); +} + +/******************************************************************************* +* Function Name: usb1_api_function_clear_nrdy_sts +* Description : Clear NRDY interrupt status in the pipe spceified by the argument. +* Arguments : uint16_t pipe ; pipe Number +* Return Value : none +*******************************************************************************/ +void usb1_api_function_clear_nrdy_sts (uint16_t pipe) +{ + usb1_function_clear_nrdy_sts(pipe); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_controlrw.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_controlrw.c new file mode 100644 index 000000000..45f8fa485 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_controlrw.c @@ -0,0 +1,142 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_controlrw.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb1_api_function_CtrlReadStart +* Description : Executes the USB control read transfer. +* : USB host controller <- USB device +* Arguments : uint16_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : DEVDRV_USBF_WRITEEND ; End of data write +* : DEVDRV_USBF_WRITESHRT ; End of short data write +* : DEVDRV_USBF_WRITING ; Continue of data write +* : DEVDRV_USBF_FIFOERROR ; FIFO access error +*******************************************************************************/ +uint16_t usb1_api_function_CtrlReadStart (uint32_t size, uint8_t * data) +{ + uint16_t status; + uint16_t mbw; + + usb1_function_set_pid_nak(USB_FUNCTION_PIPE0); + + g_usb1_function_data_count[USB_FUNCTION_PIPE0] = size; + g_usb1_function_data_pointer[USB_FUNCTION_PIPE0] = data; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[USB_FUNCTION_PIPE0], + (uint32_t)g_usb1_function_data_pointer[USB_FUNCTION_PIPE0]); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw); + USB201.CFIFOCTR = USB_FUNCTION_BITBCLR; + + status = usb1_function_write_buffer_c(USB_FUNCTION_PIPE0); + + /* Peripheral Control sequence */ + switch (status) + { + case DEVDRV_USBF_WRITESHRT: /* End of data write */ + case DEVDRV_USBF_WRITEEND: /* End of data write (not null) */ + case DEVDRV_USBF_WRITING: /* Continue of data write */ + usb1_function_enable_bemp_int(USB_FUNCTION_PIPE0); /* Enable Empty Interrupt */ + usb1_function_set_pid_buf(USB_FUNCTION_PIPE0); /* Set BUF */ + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access error */ + break; + + default: + break; + } + + return status; /* End or Err or Continue */ +} + +/******************************************************************************* +* Function Name: usb1_api_function_CtrlWriteStart +* Description : Executes the USB control write transfer. +* : USB host controller -> USB device +* Arguments : uint16_t size ; Data Size +* : uint8_t *data ; Data Address +* Return Value : none +*******************************************************************************/ +void usb1_api_function_CtrlWriteStart (uint32_t size, uint8_t * data) +{ + uint16_t mbw; + + usb1_function_set_pid_nak(USB_FUNCTION_PIPE0); + + g_usb1_function_data_count[USB_FUNCTION_PIPE0] = size; + g_usb1_function_data_pointer[USB_FUNCTION_PIPE0] = data; + + mbw = usb1_function_get_mbw(g_usb1_function_data_count[USB_FUNCTION_PIPE0], + (uint32_t)g_usb1_function_data_pointer[USB_FUNCTION_PIPE0]); + usb1_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw); + USB201.CFIFOCTR = USB_FUNCTION_BITBCLR; + + usb1_function_enable_brdy_int(USB_FUNCTION_PIPE0); + usb1_function_set_pid_buf(USB_FUNCTION_PIPE0); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_global.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_global.c new file mode 100644 index 000000000..2ca4dac59 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_global.c @@ -0,0 +1,144 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_global.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +const uint16_t g_usb1_function_bit_set[16] = +{ + 0x0001, 0x0002, 0x0004, 0x0008, + 0x0010, 0x0020, 0x0040, 0x0080, + 0x0100, 0x0200, 0x0400, 0x0800, + 0x1000, 0x2000, 0x4000, 0x8000 +}; + +uint32_t g_usb1_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint8_t * g_usb1_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1]; + +uint16_t g_usb1_function_PipeIgnore[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb1_function_PipeTbl[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb1_function_pipe_status[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint32_t g_usb1_function_PipeDataSize[USB_FUNCTION_MAX_PIPE_NO + 1]; + +USB_FUNCTION_DMA_t g_usb1_function_DmaInfo[2]; +uint16_t g_usb1_function_DmaPipe[2]; +uint16_t g_usb1_function_DmaBval[2]; +uint16_t g_usb1_function_DmaStatus[2]; + +uint16_t g_usb1_function_CtrZeroLengthFlag; + +//uint16_t g_usb1_function_ConfigNum; +//uint16_t g_usb1_function_Alternate[USB_FUNCTION_ALT_NO]; +//uint16_t g_usb1_function_RemoteWakeupFlag; +uint16_t g_usb1_function_TestModeFlag; +uint16_t g_usb1_function_TestModeSelectors; + +//uint16_t g_usb1_function_ReqType; +//uint16_t g_usb1_function_ReqTypeType; +//uint16_t g_usb1_function_ReqTypeRecip; +//uint16_t g_usb1_function_ReqRequest; +//uint16_t g_usb1_function_ReqValue; +//uint16_t g_usb1_function_ReqIndex; +//uint16_t g_usb1_function_ReqLength; + +//uint16_t g_usb1_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1]; + +uint16_t g_usb1_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb1_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb1_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1]; +uint16_t g_usb1_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1]; + + +/******************************************************************************* +* Function Name: usb1_function_init_status +* Description : Initialization USB Sample Driver Variable. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb1_function_init_status (void) +{ + uint16_t pipe; + + //g_usb1_function_ConfigNum = 0; + //g_usb1_function_RemoteWakeupFlag = DEVDRV_USBF_OFF; + g_usb1_function_TestModeFlag = DEVDRV_USBF_OFF; + g_usb1_function_CtrZeroLengthFlag = 0; + +#if 0 + usb1_function_clear_alt(); +#endif + + for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe) + { + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usb1_function_PipeDataSize[pipe] = 0; + g_usb1_function_data_count[pipe] = 0; + + /* pipe configuration in usb1_function_ResetEP() */ + g_usb1_function_pipecfg[pipe] = 0; + g_usb1_function_pipebuf[pipe] = 0; + g_usb1_function_pipemaxp[pipe] = 0; + g_usb1_function_pipeperi[pipe] = 0; + } +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sig.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sig.c new file mode 100644 index 000000000..9c0b4af89 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sig.c @@ -0,0 +1,330 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_sig.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +static void usb1_function_EnableINTModule(void); + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb1_function_InitModule +* Description : Initializes the USB module in the USB function mode. +* Arguments : uint16_t mode ; USB_FUNCTION_HIGH_SPEED ; Hi-Speed Mode +* : ; other ; Full-speed Mode +* Return Value : none +*******************************************************************************/ +void usb1_function_InitModule (uint16_t mode) +{ + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 0, + USB_SYSCFG_DCFM_SHIFT, + USB_SYSCFG_DCFM); /* USB function */ + + /* USB module operation enabled */ + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 1, + USB_SYSCFG_USBE_SHIFT, + USB_SYSCFG_USBE); + + if (mode == USB_FUNCTION_HIGH_SPEED) + { + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 1, + USB_SYSCFG_HSE_SHIFT, + USB_SYSCFG_HSE); /* Hi-Speed Mode */ + } + else + { + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 0, + USB_SYSCFG_HSE_SHIFT, + USB_SYSCFG_HSE); + } + + /* for power-on */ + if (usb1_function_CheckVBUStaus() == DEVDRV_USBF_ON) + { + usb1_function_EnableINTModule(); /* Interrupt Enable */ + usb1_function_USB_FUNCTION_Attach(); /* pull-up D+ and open D- */ + } + else + { + usb1_function_USB_FUNCTION_Detach(); /* USB Detach */ + /* with Interrupt Enable */ + } +} + +/******************************************************************************* +* Function Name: usb1_function_CheckVBUStaus +* Description : Checks the USB-VBUS state to returns the connection state to +* : the USB host. +* Arguments : none +* Return Value : DEVDRV_USBF_ON : VBUS ON +* : DEVDRV_USBF_OFF : VBUS OFF +*******************************************************************************/ +uint16_t usb1_function_CheckVBUStaus (void) +{ + uint16_t buf1; + uint16_t buf2; + uint16_t buf3; + + /* monitor VBUS pins */ + do + { + buf1 = RZA_IO_RegRead_16(&USB201.INTSTS0, + USB_INTSTS0_VBSTS_SHIFT, + USB_INTSTS0_VBSTS); + Userdef_USB_usb1_function_delay_10us(1); + buf2 = RZA_IO_RegRead_16(&USB201.INTSTS0, + USB_INTSTS0_VBSTS_SHIFT, + USB_INTSTS0_VBSTS); + Userdef_USB_usb1_function_delay_10us(1); + buf3 = RZA_IO_RegRead_16(&USB201.INTSTS0, + USB_INTSTS0_VBSTS_SHIFT, + USB_INTSTS0_VBSTS); + } while ((buf1 != buf2) || (buf2 != buf3)); + + if (buf1 == DEVDRV_USBF_OFF) + { + return DEVDRV_USBF_OFF; /* detach */ + } + + return DEVDRV_USBF_ON; /* attach */ +} + +/******************************************************************************* +* Function Name: usb1_function_USB_FUNCTION_Attach +* Description : Connects to the USB host controller. +* : This function pulls up D+. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb1_function_USB_FUNCTION_Attach (void) +{ + Userdef_USB_usb1_function_attach(); + + Userdef_USB_usb1_function_delay_xms(10); + + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 1, + USB_SYSCFG_DPRPU_SHIFT, + USB_SYSCFG_DPRPU); /* Pull-up D+ and open D- */ +} + +/******************************************************************************* +* Function Name: usb1_function_USB_FUNCTION_Detach +* Description : Disconnects from the USB host controller. +* : This function opens D+/D-. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb1_function_USB_FUNCTION_Detach (void) +{ + uint16_t pipe; + + Userdef_USB_usb1_function_detach(); + + for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe) + { + if (g_usb1_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_IDLE) + { + usb1_function_stop_transfer(pipe); + } + } + + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 0, + USB_SYSCFG_DPRPU_SHIFT, + USB_SYSCFG_DPRPU); /* open D+ and D- */ + + /* Detach Recovery */ + Userdef_USB_usb1_function_delay_500ns(); /* need 1us=500ns * 2 wait */ + Userdef_USB_usb1_function_delay_500ns(); + + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 1, + USB_SYSCFG_DCFM_SHIFT, + USB_SYSCFG_DCFM); + Userdef_USB_usb1_function_delay_500ns(); /* need 100ns wait but 500ns S/W wait */ + + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 0, + USB_SYSCFG_DCFM_SHIFT, + USB_SYSCFG_DCFM); + + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 0, + USB_SYSCFG_USBE_SHIFT, + USB_SYSCFG_USBE); /* soft reset module */ + Userdef_USB_usb1_function_delay_500ns(); + + RZA_IO_RegWrite_16(&USB201.SYSCFG0, + 1, + USB_SYSCFG_USBE_SHIFT, + USB_SYSCFG_USBE); + + usb1_function_EnableINTModule(); /* Interrupt Enable */ +} + +/******************************************************************************* +* Function Name: usb1_function_USB_FUNCTION_BusReset +* Description : This function is executed when the USB device is transitioned +* : to POWERD_STATE. Sets the device descriptor according to the +* : connection speed determined by the USB reset hand shake. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 /*The USBHAL in mbed does not need this function*/ +void usb1_function_USB_FUNCTION_BusReset (void) +{ + usb1_function_init_status(); /* memory clear */ + + if (usb1_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED) + { + usb1_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED); /* Device Descriptor reset */ + } + else + { + usb1_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED); /* Device Descriptor reset */ + } + + usb1_function_ResetDCP(); /* Default Control PIPE reset */ +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_USB_FUNCTION_Resume +* Description : This function is executed when the USB device detects a resume +* : signal. +* : The USB sample driver does not operate for this function. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 /*The USBHAL in mbed does not need this function*/ +void usb1_function_USB_FUNCTION_Resume (void) +{ + /* NOP */ +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_USB_FUNCTION_Suspend +* Description : This function is executed when the USB device detects a suspend +* : signal. +* : The USB sample driver does not operate for this function. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 /*The USBHAL in mbed does not need this function*/ +void usb1_function_USB_FUNCTION_Suspend (void) +{ + /* NOP */ +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_USB_FUNCTION_TestMode +* Description : This function is executed when the USB device is transitioned U +* : to TEST_MODE by the USB standard request. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb1_function_USB_FUNCTION_TestMode (void) +{ + switch (g_usb1_function_TestModeSelectors & USB_FUNCTION_FUNCTION_TEST_SELECT) + { + case USB_FUNCTION_FUNCTION_TEST_J: + case USB_FUNCTION_FUNCTION_TEST_K: + case USB_FUNCTION_FUNCTION_TEST_SE0_NAK: + case USB_FUNCTION_FUNCTION_TEST_PACKET: + RZA_IO_RegWrite_16(&USB201.TESTMODE, + (g_usb1_function_TestModeSelectors >> 8), + USB_TESTMODE_UTST_SHIFT, + USB_TESTMODE_UTST); + break; + + case USB_FUNCTION_FUNCTION_TEST_FORCE_ENABLE: + default: + break; + } +} + +/******************************************************************************* +* Function Name: usb1_function_EnableINTModule +* Description : Enables USB interrupt. +* Arguments : none +* Return Value : none +*******************************************************************************/ +static void usb1_function_EnableINTModule (void) +{ + uint16_t buf; + + buf = USB201.INTENB0; + buf |= (USB_FUNCTION_BITVBSE | USB_FUNCTION_BITDVSE | USB_FUNCTION_BITCTRE | + USB_FUNCTION_BITBEMPE | USB_FUNCTION_BITNRDYE | USB_FUNCTION_BITBRDYE); + USB201.INTENB0 = buf; + + usb1_function_enable_bemp_int(USB_FUNCTION_PIPE0); +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sub.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sub.c new file mode 100644 index 000000000..bdb548a5f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sub.c @@ -0,0 +1,453 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_sub.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include "usb1_function.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ +#if 0 +extern const uint16_t *g_usb1_function_EndPntPtr[]; +extern uint8_t g_usb1_function_DeviceDescriptor[]; +extern uint8_t *g_usb1_function_ConfigurationPtr[]; +#endif + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: usb1_function_ResetDCP +* Description : Initializes the default control pipe(DCP). +* Outline : Reset default control pipe +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb1_function_ResetDCP (void) +{ + USB201.DCPCFG = 0; +#if 0 + USB201.DCPMAXP = g_usb1_function_DeviceDescriptor[7]; +#else + USB201.DCPMAXP = 64; +#endif + + USB201.CFIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + USB201.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + USB201.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); +} + +/******************************************************************************* +* Function Name: usb1_function_ResetEP +* Description : Initializes the end point. +* Arguments : uint16_t num ; Configuration Number +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_function_ResetEP (uint16_t num) +{ + uint16_t pipe; + uint16_t ep; + uint16_t index; + uint16_t buf; + uint16_t * tbl; + + tbl = (uint16_t *)(g_usb1_function_EndPntPtr[num - 1]); + + for (ep = 1; ep <= USB_FUNCTION_MAX_EP_NO; ++ep) + { + if (g_usb1_function_EPTableIndex[ep] != USB_FUNCTION_EP_ERROR) + { + index = (uint16_t)(USB_FUNCTION_EPTABLE_LENGTH * g_usb1_function_EPTableIndex[ep]); + pipe = (uint16_t)(tbl[index + 0] & USB_FUNCTION_BITCURPIPE); + + g_usb1_function_PipeTbl[pipe] = (uint16_t)(((tbl[index + 1] & USB_FUNCTION_DIRFIELD) << 3) | + ep | + (tbl[index + 0] & USB_FUNCTION_FIFO_USE)); + + if ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) == USB_FUNCTION_DIR_P_OUT) + { + tbl[index + 1] |= USB_FUNCTION_SHTNAKON; +#ifdef __USB_DMA_BFRE_ENABLE__ + /* this routine cannnot be perfomred if read operation is executed in buffer size */ + if (((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) || + ((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA)) + { + tbl[index + 1] |= USB_FUNCTION_BFREON; + } +#endif + } + + /* Interrupt Disable */ + buf = USB201.BRDYENB; + buf &= (uint16_t)~g_usb1_function_bit_set[pipe]; + USB201.BRDYENB = buf; + buf = USB201.NRDYENB; + buf &= (uint16_t)~g_usb1_function_bit_set[pipe]; + USB201.NRDYENB = buf; + buf = USB201.BEMPENB; + buf &= (uint16_t)~g_usb1_function_bit_set[pipe]; + USB201.BEMPENB = buf; + + usb1_function_set_pid_nak(pipe); + + /* CurrentPIPE Clear */ + if (RZA_IO_RegRead_16(&USB201.CFIFOSEL, + USB_CFIFOSEL_CURPIPE_SHIFT, + USB_CFIFOSEL_CURPIPE) == pipe) + { + RZA_IO_RegWrite_16(&USB201.CFIFOSEL, + 0, + USB_CFIFOSEL_CURPIPE_SHIFT, + USB_CFIFOSEL_CURPIPE); + } + + if (RZA_IO_RegRead_16(&USB201.D0FIFOSEL, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE) == pipe) + { + RZA_IO_RegWrite_16(&USB201.D0FIFOSEL, + 0, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE); + } + + if (RZA_IO_RegRead_16(&USB201.D1FIFOSEL, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE) == pipe) + { + RZA_IO_RegWrite_16(&USB201.D1FIFOSEL, + 0, + USB_DnFIFOSEL_CURPIPE_SHIFT, + USB_DnFIFOSEL_CURPIPE); + } + + /* PIPE Configuration */ + USB201.PIPESEL = pipe; + USB201.PIPECFG = tbl[index + 1]; + USB201.PIPEBUF = tbl[index + 2]; + USB201.PIPEMAXP = tbl[index + 3]; + USB201.PIPEPERI = tbl[index + 4]; + + g_usb1_function_pipecfg[pipe] = tbl[index + 1]; + g_usb1_function_pipebuf[pipe] = tbl[index + 2]; + g_usb1_function_pipemaxp[pipe] = tbl[index + 3]; + g_usb1_function_pipeperi[pipe] = tbl[index + 4]; + + /* Buffer Clear */ + usb1_function_set_sqclr(pipe); + usb1_function_aclrm(pipe); + + /* init Global */ + g_usb1_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usb1_function_PipeDataSize[pipe] = 0; + } + } +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_EpToPipe +* Description : Returns the pipe which end point specified by the argument is +* : allocated to. +* Arguments : uint16_t ep ; Direction + Endpoint Number +* Return Value : USB_FUNCTION_EP_ERROR : Error +* : Others : Pipe Number +*******************************************************************************/ +uint16_t usb1_function_EpToPipe (uint16_t ep) +{ + uint16_t pipe; + + for (pipe = 1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) + { + if ((g_usb1_function_PipeTbl[pipe] & 0x00ff) == ep) + { + return pipe; + } + } + + return USB_FUNCTION_EP_ERROR; +} + +/******************************************************************************* +* Function Name: usb1_function_InitEPTable +* Description : Sets the end point by the Alternate setting value of the +* : configuration number and the interface number specified by the +* : argument. +* Arguments : uint16_t Con_Num ; Configuration Number +* : uint16_t Int_Num ; Interface Number +* : uint16_t Alt_Num ; Alternate Setting +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_function_InitEPTable (uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num) +{ + uint8_t * ptr; + uint16_t point_interface; + uint16_t point_endpoint; + uint16_t length; + uint16_t start; + uint16_t numbers; + uint16_t endpoint; + + ptr = (uint8_t *)g_usb1_function_ConfigurationPtr[Con_Num - 1]; + point_interface = *ptr; + length = (uint16_t)((uint16_t)*(ptr + 3) << 8 | (uint16_t)*(ptr + 2)); + ptr += *ptr; + start = 0; + numbers = 0; + point_endpoint = 0; + + for (; point_interface < length;) + { + switch (*(ptr + 1)) /* Descriptor Type ? */ + { + case USB_FUNCTION_DT_INTERFACE: /* Interface */ + if ((*(ptr + 2) == Int_Num) && (*(ptr + 3) == Alt_Num)) + { + numbers = *(ptr + 4); + } + else + { + start += *(ptr + 4); + } + point_interface += *ptr; + ptr += *ptr; + break; + + case USB_FUNCTION_DT_ENDPOINT: /* Endpoint */ + if (point_endpoint < numbers) + { + endpoint = (uint16_t)(*(ptr + 2) & 0x0f); + g_usb1_function_EPTableIndex[endpoint] = (uint16_t)(start + point_endpoint); + ++point_endpoint; + } + point_interface += *ptr; + ptr += *ptr; + break; + + case USB_FUNCTION_DT_DEVICE: /* Device */ + case USB_FUNCTION_DT_CONFIGURATION: /* Configuration */ + case USB_FUNCTION_DT_STRING: /* String */ + default: /* Class, Vendor, else */ + point_interface += *ptr; + ptr += *ptr; + break; + } + } +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_GetConfigNum +* Description : Returns the number of configuration referring to the number of +* : configuration described in the device descriptor. +* Arguments : none +* Return Value : Number of possible configurations (bNumConfigurations). +*******************************************************************************/ +#if 0 +uint16_t usb1_function_GetConfigNum (void) +{ + return (uint16_t)g_usb1_function_DeviceDescriptor[17]; +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_GetInterfaceNum +* Description : Returns the number of interface referring to the number of +* : interface described in the configuration descriptor. +* Arguments : uint16_t num ; Configuration Number +* Return Value : Number of this interface (bNumInterfaces). +*******************************************************************************/ +#if 0 +uint16_t usb1_function_GetInterfaceNum (uint16_t num) +{ + return (uint16_t)(*(g_usb1_function_ConfigurationPtr[num - 1] + 4)); +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_GetAltNum +* Description : Returns the Alternate setting value of the configuration number +* : and the interface number specified by the argument. +* Arguments : uint16_t Con_Num ; Configuration Number +* : uint16_t Int_Num ; Interface Number +* Return Value : Value used to select this alternate setting(bAlternateSetting). +*******************************************************************************/ +#if 0 +uint16_t usb1_function_GetAltNum (uint16_t Con_Num, uint16_t Int_Num) +{ + uint8_t * ptr; + uint16_t point; + uint16_t alt_num = 0; + uint16_t length; + + ptr = (uint8_t *)(g_usb1_function_ConfigurationPtr[Con_Num - 1]); + point = ptr[0]; + ptr += ptr[0]; /* InterfaceDescriptor[0] */ + length = (uint16_t)(*(g_usb1_function_ConfigurationPtr[Con_Num - 1] + 2)); + length |= (uint16_t)((uint16_t)(*(g_usb1_function_ConfigurationPtr[Con_Num - 1] + 3)) << 8); + + for (; point < length;) /* Search Descriptor Table size */ + { + switch (ptr[1]) /* Descriptor Type ? */ + { + case USB_FUNCTION_DT_INTERFACE: /* Interface */ + if (Int_Num == ptr[2]) + { + alt_num = (uint16_t)ptr[3]; /* Alternate Number count */ + } + point += ptr[0]; + ptr += ptr[0]; + break; + + case USB_FUNCTION_DT_DEVICE: /* Device */ + case USB_FUNCTION_DT_CONFIGURATION: /* Configuration */ + case USB_FUNCTION_DT_STRING: /* String */ + case USB_FUNCTION_DT_ENDPOINT: /* Endpoint */ + default: /* Class, Vendor, else */ + point += ptr[0]; + ptr += ptr[0]; + break; + } + } + return alt_num; +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_CheckRemoteWakeup +* Description : Returns the result of the remote wake up function is supported +* : or not referring to the configuration descriptor. +* Arguments : none +* Return Value : DEVDRV_USBF_ON : Support Remote Wakeup +* : DEVDRV_USBF_OFF : not Support Remote Wakeup +*******************************************************************************/ +#if 0 +uint16_t usb1_function_CheckRemoteWakeup (void) +{ + uint8_t atr; + + if (g_usb1_function_ConfigNum == 0) + { + return DEVDRV_USBF_OFF; + } + + atr = *(g_usb1_function_ConfigurationPtr[g_usb1_function_ConfigNum - 1] + 7); + + if (atr & USB_FUNCTION_CF_RWUP) + { + return DEVDRV_USBF_ON; + } + + return DEVDRV_USBF_OFF; +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_clear_alt +* Description : Initializes the Alternate setting area. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_function_clear_alt (void) +{ + int i; + + for (i = 0; i < USB_FUNCTION_ALT_NO; ++i) + { + g_usb1_function_Alternate[i] = 0; /* Alternate */ + } +} +#endif + +/******************************************************************************* +* Function Name: usb1_function_clear_pipe_tbl +* Description : Initializes pipe definition table. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void usb1_function_clear_pipe_tbl (void) +{ + int pipe; + + for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe) + { + g_usb1_function_PipeTbl[pipe] = 0; + } +} + +/******************************************************************************* +* Function Name: usb1_function_clear_ep_table_index +* Description : Initializes the end point table index. +* Arguments : none +* Return Value : none +*******************************************************************************/ +#if 0 +void usb1_function_clear_ep_table_index (void) +{ + int ep; + + for (ep = 0; ep <= USB_FUNCTION_MAX_EP_NO; ++ep) + { + g_usb1_function_EPTableIndex[ep] = USB_FUNCTION_EP_ERROR; + } +} +#endif + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_dmacdrv.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_dmacdrv.c new file mode 100644 index 000000000..809f682a0 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_dmacdrv.c @@ -0,0 +1,698 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_dmacdrv.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include <stdio.h> +#include "r_typedefs.h" +#include "iodefine.h" +#include "rza_io_regrw.h" +#include "usb1_function_dmacdrv.h" + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +#define DMAC_INDEFINE (255) /* Macro definition when REQD bit is not used */ + +/* ==== Request setting information for on-chip peripheral module ==== */ +typedef enum dmac_peri_req_reg_type +{ + DMAC_REQ_MID, + DMAC_REQ_RID, + DMAC_REQ_AM, + DMAC_REQ_LVL, + DMAC_REQ_REQD +} dmac_peri_req_reg_type_t; + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ +/* ==== Prototype declaration ==== */ + +/* ==== Global variable ==== */ +/* On-chip peripheral module request setting table */ +static const uint8_t usb1_function_dmac_peri_req_init_table[8][5] = +{ + /* MID,RID,AM,LVL,REQD */ + {32, 3, 2, 1, 1}, /* USB_0 channel 0 transmit FIFO empty */ + {32, 3, 2, 1, 0}, /* USB_0 channel 0 receive FIFO full */ + {33, 3, 2, 1, 1}, /* USB_0 channel 1 transmit FIFO empty */ + {33, 3, 2, 1, 0}, /* USB_0 channel 1 receive FIFO full */ + {34, 3, 2, 1, 1}, /* USB_1 channel 0 transmit FIFO empty */ + {34, 3, 2, 1, 0}, /* USB_1 channel 0 receive FIFO full */ + {35, 3, 2, 1, 1}, /* USB_1 channel 1 transmit FIFO empty */ + {35, 3, 2, 1, 0}, /* USB_1 channel 1 receive FIFO full */ +}; + + +/******************************************************************************* +* Function Name: usb1_function_DMAC3_PeriReqInit +* Description : Sets the register mode for DMA mode and the on-chip peripheral +* : module request for transfer request for DMAC channel 1. +* : Executes DMAC initial setting using the DMA information +* : specified by the argument *trans_info and the enabled/disabled +* : continuous transfer specified by the argument continuation. +* : Registers DMAC channel 1 interrupt handler function and sets +* : the interrupt priority level. Then enables transfer completion +* : interrupt. +* Arguments : dmac_transinfo_t *trans_info : Setting information to DMAC register +* : uint32_t dmamode : DMA mode (only for DMAC_MODE_REGISTER) +* : uint32_t continuation : Set continuous transfer to be valid +* : after DMA transfer has been completed +* : DMAC_SAMPLE_CONTINUATION : Execute continuous transfer +* : DMAC_SAMPLE_SINGLE : Do not execute continuous transfer +* : uint32_t request_factor : Factor for on-chip peripheral module request +* : DMAC_REQ_OSTM0TINT : OSTM_0 compare match +* : DMAC_REQ_OSTM1TINT : OSTM_1 compare match +* : DMAC_REQ_TGI0A : MTU2_0 input capture/compare match +* : : +* : uint32_t req_direction: Setting value of CHCFG_n register REQD bit +* Return Value : none +*******************************************************************************/ +void usb1_function_DMAC3_PeriReqInit (const dmac_transinfo_t * trans_info, + uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction) +{ + /* ==== Register mode ==== */ + if (DMAC_MODE_REGISTER == dmamode) + { + /* ==== Next0 register set ==== */ + DMAC3.N0SA_n = trans_info->src_addr; /* Start address of transfer source */ + DMAC3.N0DA_n = trans_info->dst_addr; /* Start address of transfer destination */ + DMAC3.N0TB_n = trans_info->count; /* Total transfer byte count */ + + /* DAD : Transfer destination address counting direction */ + /* SAD : Transfer source address counting direction */ + /* DDS : Transfer destination transfer size */ + /* SDS : Transfer source transfer size */ + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + trans_info->daddr_dir, + DMAC3_CHCFG_n_DAD_SHIFT, + DMAC3_CHCFG_n_DAD); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + trans_info->saddr_dir, + DMAC3_CHCFG_n_SAD_SHIFT, + DMAC3_CHCFG_n_SAD); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + trans_info->dst_size, + DMAC3_CHCFG_n_DDS_SHIFT, + DMAC3_CHCFG_n_DDS); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + trans_info->src_size, + DMAC3_CHCFG_n_SDS_SHIFT, + DMAC3_CHCFG_n_SDS); + + /* DMS : Register mode */ + /* RSEL : Select Next0 register set */ + /* SBE : No discharge of buffer data when aborted */ + /* DEM : No DMA interrupt mask */ + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_DMS_SHIFT, + DMAC3_CHCFG_n_DMS); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_RSEL_SHIFT, + DMAC3_CHCFG_n_RSEL); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_SBE_SHIFT, + DMAC3_CHCFG_n_SBE); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_DEM_SHIFT, + DMAC3_CHCFG_n_DEM); + + /* ---- Continuous transfer ---- */ + if (DMAC_SAMPLE_CONTINUATION == continuation) + { + /* REN : Execute continuous transfer */ + /* RSW : Change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 1, + DMAC3_CHCFG_n_REN_SHIFT, + DMAC3_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 1, + DMAC3_CHCFG_n_RSW_SHIFT, + DMAC3_CHCFG_n_RSW); + } + /* ---- Single transfer ---- */ + else + { + /* REN : Do not execute continuous transfer */ + /* RSW : Do not change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_REN_SHIFT, + DMAC3_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_RSW_SHIFT, + DMAC3_CHCFG_n_RSW); + } + + /* TM : Single transfer */ + /* SEL : Channel setting */ + /* HIEN, LOEN : On-chip peripheral module request */ + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_TM_SHIFT, + DMAC3_CHCFG_n_TM); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 3, + DMAC3_CHCFG_n_SEL_SHIFT, + DMAC3_CHCFG_n_SEL); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 1, + DMAC3_CHCFG_n_HIEN_SHIFT, + DMAC3_CHCFG_n_HIEN); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + 0, + DMAC3_CHCFG_n_LOEN_SHIFT, + DMAC3_CHCFG_n_LOEN); + + /* ---- Set factor by specified on-chip peripheral module request ---- */ + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM], + DMAC3_CHCFG_n_AM_SHIFT, + DMAC3_CHCFG_n_AM); + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL], + DMAC3_CHCFG_n_LVL_SHIFT, + DMAC3_CHCFG_n_LVL); + + if (usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE) + { + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD], + DMAC3_CHCFG_n_REQD_SHIFT, + DMAC3_CHCFG_n_REQD); + } + else + { + RZA_IO_RegWrite_32(&DMAC3.CHCFG_n, + req_direction, + DMAC3_CHCFG_n_REQD_SHIFT, + DMAC3_CHCFG_n_REQD); + } + + RZA_IO_RegWrite_32(&DMAC23.DMARS, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID], + DMAC23_DMARS_CH3_RID_SHIFT, + DMAC23_DMARS_CH3_RID); + RZA_IO_RegWrite_32(&DMAC23.DMARS, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID], + DMAC23_DMARS_CH3_MID_SHIFT, + DMAC23_DMARS_CH3_MID); + + /* PR : Round robin mode */ + RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7, + 1, + DMAC07_DCTRL_0_7_PR_SHIFT, + DMAC07_DCTRL_0_7_PR); + } +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC3_Open +* Description : Enables DMAC channel 3 transfer. +* Arguments : uint32_t req : DMAC request mode +* Return Value : 0 : Succeeded in enabling DMA transfer +* : -1 : Failed to enable DMA transfer (due to DMA operation) +*******************************************************************************/ +int32_t usb1_function_DMAC3_Open (uint32_t req) +{ + int32_t ret; + volatile uint8_t dummy; + + /* Transferable? */ + if ((0 == RZA_IO_RegRead_32(&DMAC3.CHSTAT_n, + DMAC3_CHSTAT_n_EN_SHIFT, + DMAC3_CHSTAT_n_EN)) && + (0 == RZA_IO_RegRead_32(&DMAC3.CHSTAT_n, + DMAC3_CHSTAT_n_TACT_SHIFT, + DMAC3_CHSTAT_n_TACT))) + { + /* Clear Channel Status Register */ + RZA_IO_RegWrite_32(&DMAC3.CHCTRL_n, + 1, + DMAC3_CHCTRL_n_SWRST_SHIFT, + DMAC3_CHCTRL_n_SWRST); + dummy = RZA_IO_RegRead_32(&DMAC3.CHCTRL_n, + DMAC3_CHCTRL_n_SWRST_SHIFT, + DMAC3_CHCTRL_n_SWRST); + /* Enable DMA transfer */ + RZA_IO_RegWrite_32(&DMAC3.CHCTRL_n, + 1, + DMAC3_CHCTRL_n_SETEN_SHIFT, + DMAC3_CHCTRL_n_SETEN); + + /* ---- Request by software ---- */ + if (DMAC_REQ_MODE_SOFT == req) + { + /* DMA transfer Request by software */ + RZA_IO_RegWrite_32(&DMAC3.CHCTRL_n, + 1, + DMAC3_CHCTRL_n_STG_SHIFT, + DMAC3_CHCTRL_n_STG); + } + + ret = 0; + } + else + { + ret = -1; + } + + return ret; +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC3_Close +* Description : Aborts DMAC channel 3 transfer. Returns the remaining transfer +* : byte count at the time of DMA transfer abort to the argument +* : *remain. +* Arguments : uint32_t * remain : Remaining transfer byte count when +* : : DMA transfer is aborted +* Return Value : none +*******************************************************************************/ +void usb1_function_DMAC3_Close (uint32_t * remain) +{ + + /* ==== Abort transfer ==== */ + RZA_IO_RegWrite_32(&DMAC3.CHCTRL_n, + 1, + DMAC3_CHCTRL_n_CLREN_SHIFT, + DMAC3_CHCTRL_n_CLREN); + + while (1 == RZA_IO_RegRead_32(&DMAC3.CHSTAT_n, + DMAC3_CHSTAT_n_TACT_SHIFT, + DMAC3_CHSTAT_n_TACT)) + { + /* Loop until transfer is aborted */ + } + + while (1 == RZA_IO_RegRead_32(&DMAC3.CHSTAT_n, + DMAC3_CHSTAT_n_EN_SHIFT, + DMAC3_CHSTAT_n_EN)) + { + /* Loop until 0 is set in EN before checking the remaining transfer byte count */ + } + /* ==== Obtain remaining transfer byte count ==== */ + *remain = DMAC3.CRTB_n; +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC3_Load_Set +* Description : Sets the transfer source address, transfer destination +* : address, and total transfer byte count respectively +* : specified by the argument src_addr, dst_addr, and count to +* : DMAC channel 3 as DMA transfer information. +* : Sets the register set selected by the CHCFG_n register +* : RSEL bit from the Next0 or Next1 register set. +* : This function should be called when DMA transfer of DMAC +* : channel 3 is aboted. +* Arguments : uint32_t src_addr : Transfer source address +* : uint32_t dst_addr : Transfer destination address +* : uint32_t count : Total transfer byte count +* Return Value : none +*******************************************************************************/ +void usb1_function_DMAC3_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count) +{ + uint8_t reg_set; + + /* Obtain register set in use */ + reg_set = RZA_IO_RegRead_32(&DMAC3.CHSTAT_n, + DMAC3_CHSTAT_n_SR_SHIFT, + DMAC3_CHSTAT_n_SR); + + /* ==== Load ==== */ + if (0 == reg_set) + { + /* ---- Next0 Register Set ---- */ + DMAC3.N0SA_n = src_addr; /* Start address of transfer source */ + DMAC3.N0DA_n = dst_addr; /* Start address of transfer destination */ + DMAC3.N0TB_n = count; /* Total transfer byte count */ + } + else + { + /* ---- Next1 Register Set ---- */ + DMAC3.N1SA_n = src_addr; /* Start address of transfer source */ + DMAC3.N1DA_n = dst_addr; /* Start address of transfer destination */ + DMAC3.N1TB_n = count; /* Total transfer byte count */ + } +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC4_PeriReqInit +* Description : Sets the register mode for DMA mode and the on-chip peripheral +* : module request for transfer request for DMAC channel 2. +* : Executes DMAC initial setting using the DMA information +* : specified by the argument *trans_info and the enabled/disabled +* : continuous transfer specified by the argument continuation. +* : Registers DMAC channel 2 interrupt handler function and sets +* : the interrupt priority level. Then enables transfer completion +* : interrupt. +* Arguments : dmac_transinfo_t * trans_info : Setting information to DMAC +* : : register +* : uint32_t dmamode : DMA mode (only for DMAC_MODE_REGISTER) +* : uint32_t continuation : Set continuous transfer to be valid +* : : after DMA transfer has been completed +* : DMAC_SAMPLE_CONTINUATION : Execute continuous transfer +* : DMAC_SAMPLE_SINGLE : Do not execute continuous +* : : transfer +* : uint32_t request_factor : Factor for on-chip peripheral module +* : : request +* : DMAC_REQ_OSTM0TINT : OSTM_0 compare match +* : DMAC_REQ_OSTM1TINT : OSTM_1 compare match +* : DMAC_REQ_TGI0A : MTU2_0 input capture/compare match +* : : +* : uint32_t req_direction : Setting value of CHCFG_n register +* : : REQD bit +*******************************************************************************/ +void usb1_function_DMAC4_PeriReqInit (const dmac_transinfo_t * trans_info, + uint32_t dmamode, uint32_t continuation, + uint32_t request_factor, uint32_t req_direction) +{ + /* ==== Register mode ==== */ + if (DMAC_MODE_REGISTER == dmamode) + { + /* ==== Next0 register set ==== */ + DMAC4.N0SA_n = trans_info->src_addr; /* Start address of transfer source */ + DMAC4.N0DA_n = trans_info->dst_addr; /* Start address of transfer destination */ + DMAC4.N0TB_n = trans_info->count; /* Total transfer byte count */ + + /* DAD : Transfer destination address counting direction */ + /* SAD : Transfer source address counting direction */ + /* DDS : Transfer destination transfer size */ + /* SDS : Transfer source transfer size */ + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + trans_info->daddr_dir, + DMAC4_CHCFG_n_DAD_SHIFT, + DMAC4_CHCFG_n_DAD); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + trans_info->saddr_dir, + DMAC4_CHCFG_n_SAD_SHIFT, + DMAC4_CHCFG_n_SAD); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + trans_info->dst_size, + DMAC4_CHCFG_n_DDS_SHIFT, + DMAC4_CHCFG_n_DDS); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + trans_info->src_size, + DMAC4_CHCFG_n_SDS_SHIFT, + DMAC4_CHCFG_n_SDS); + + /* DMS : Register mode */ + /* RSEL : Select Next0 register set */ + /* SBE : No discharge of buffer data when aborted */ + /* DEM : No DMA interrupt mask */ + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_DMS_SHIFT, + DMAC4_CHCFG_n_DMS); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_RSEL_SHIFT, + DMAC4_CHCFG_n_RSEL); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_SBE_SHIFT, + DMAC4_CHCFG_n_SBE); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_DEM_SHIFT, + DMAC4_CHCFG_n_DEM); + + /* ---- Continuous transfer ---- */ + if (DMAC_SAMPLE_CONTINUATION == continuation) + { + /* REN : Execute continuous transfer */ + /* RSW : Change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 1, + DMAC4_CHCFG_n_REN_SHIFT, + DMAC4_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 1, + DMAC4_CHCFG_n_RSW_SHIFT, + DMAC4_CHCFG_n_RSW); + } + /* ---- Single transfer ---- */ + else + { + /* REN : Do not execute continuous transfer */ + /* RSW : Do not change register set when DMA transfer is completed. */ + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_REN_SHIFT, + DMAC4_CHCFG_n_REN); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_RSW_SHIFT, + DMAC4_CHCFG_n_RSW); + } + + /* TM : Single transfer */ + /* SEL : Channel setting */ + /* HIEN, LOEN : On-chip peripheral module request */ + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_TM_SHIFT, + DMAC4_CHCFG_n_TM); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 4, + DMAC4_CHCFG_n_SEL_SHIFT, + DMAC4_CHCFG_n_SEL); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 1, + DMAC4_CHCFG_n_HIEN_SHIFT, + DMAC4_CHCFG_n_HIEN); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + 0, + DMAC4_CHCFG_n_LOEN_SHIFT, + DMAC4_CHCFG_n_LOEN); + + /* ---- Set factor by specified on-chip peripheral module request ---- */ + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM], + DMAC4_CHCFG_n_AM_SHIFT, + DMAC4_CHCFG_n_AM); + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL], + DMAC4_CHCFG_n_LVL_SHIFT, + DMAC4_CHCFG_n_LVL); + if (usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE) + { + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD], + DMAC4_CHCFG_n_REQD_SHIFT, + DMAC4_CHCFG_n_REQD); + } + else + { + RZA_IO_RegWrite_32(&DMAC4.CHCFG_n, + req_direction, + DMAC4_CHCFG_n_REQD_SHIFT, + DMAC4_CHCFG_n_REQD); + } + RZA_IO_RegWrite_32(&DMAC45.DMARS, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID], + DMAC45_DMARS_CH4_RID_SHIFT, + DMAC45_DMARS_CH4_RID); + RZA_IO_RegWrite_32(&DMAC45.DMARS, + usb1_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID], + DMAC45_DMARS_CH4_MID_SHIFT, + DMAC45_DMARS_CH4_MID); + + /* PR : Round robin mode */ + RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7, + 1, + DMAC07_DCTRL_0_7_PR_SHIFT, + DMAC07_DCTRL_0_7_PR); + } +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC4_Open +* Description : Enables DMAC channel 4 transfer. +* Arguments : uint32_t req : DMAC request mode +* Return Value : 0 : Succeeded in enabling DMA transfer +* : -1 : Failed to enable DMA transfer (due to DMA operation) +*******************************************************************************/ +int32_t usb1_function_DMAC4_Open (uint32_t req) +{ + int32_t ret; + volatile uint8_t dummy; + + /* Transferable? */ + if ((0 == RZA_IO_RegRead_32(&DMAC4.CHSTAT_n, + DMAC4_CHSTAT_n_EN_SHIFT, + DMAC4_CHSTAT_n_EN)) && + (0 == RZA_IO_RegRead_32(&DMAC4.CHSTAT_n, + DMAC4_CHSTAT_n_TACT_SHIFT, + DMAC4_CHSTAT_n_TACT))) + { + /* Clear Channel Status Register */ + RZA_IO_RegWrite_32(&DMAC4.CHCTRL_n, + 1, + DMAC4_CHCTRL_n_SWRST_SHIFT, + DMAC4_CHCTRL_n_SWRST); + dummy = RZA_IO_RegRead_32(&DMAC4.CHCTRL_n, + DMAC4_CHCTRL_n_SWRST_SHIFT, + DMAC4_CHCTRL_n_SWRST); + /* Enable DMA transfer */ + RZA_IO_RegWrite_32(&DMAC4.CHCTRL_n, + 1, + DMAC4_CHCTRL_n_SETEN_SHIFT, + DMAC4_CHCTRL_n_SETEN); + + /* ---- Request by software ---- */ + if (DMAC_REQ_MODE_SOFT == req) + { + /* DMA transfer Request by software */ + RZA_IO_RegWrite_32(&DMAC4.CHCTRL_n, + 1, + DMAC4_CHCTRL_n_STG_SHIFT, + DMAC4_CHCTRL_n_STG); + } + + ret = 0; + } + else + { + ret = -1; + } + + return ret; +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC4_Close +* Description : Aborts DMAC channel 4 transfer. Returns the remaining transfer +* : byte count at the time of DMA transfer abort to the argument +* : *remain. +* Arguments : uint32_t * remain : Remaining transfer byte count when +* : : DMA transfer is aborted +* Return Value : none +*******************************************************************************/ +void usb1_function_DMAC4_Close (uint32_t * remain) +{ + + /* ==== Abort transfer ==== */ + RZA_IO_RegWrite_32(&DMAC4.CHCTRL_n, + 1, + DMAC4_CHCTRL_n_CLREN_SHIFT, + DMAC4_CHCTRL_n_CLREN); + + while (1 == RZA_IO_RegRead_32(&DMAC4.CHSTAT_n, + DMAC4_CHSTAT_n_TACT_SHIFT, + DMAC4_CHSTAT_n_TACT)) + { + /* Loop until transfer is aborted */ + } + + while (1 == RZA_IO_RegRead_32(&DMAC4.CHSTAT_n, + DMAC4_CHSTAT_n_EN_SHIFT, + DMAC4_CHSTAT_n_EN)) + { + /* Loop until 0 is set in EN before checking the remaining transfer byte count */ + } + /* ==== Obtain remaining transfer byte count ==== */ + *remain = DMAC4.CRTB_n; +} + +/******************************************************************************* +* Function Name: usb1_function_DMAC4_Load_Set +* Description : Sets the transfer source address, transfer destination +* : address, and total transfer byte count respectively +* : specified by the argument src_addr, dst_addr, and count to +* : DMAC channel 4 as DMA transfer information. +* : Sets the register set selected by the CHCFG_n register +* : RSEL bit from the Next0 or Next1 register set. +* : This function should be called when DMA transfer of DMAC +* : channel 4 is aboted. +* Arguments : uint32_t src_addr : Transfer source address +* : uint32_t dst_addr : Transfer destination address +* : uint32_t count : Total transfer byte count +* Return Value : none +*******************************************************************************/ +void usb1_function_DMAC4_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count) +{ + uint8_t reg_set; + + /* Obtain register set in use */ + reg_set = RZA_IO_RegRead_32(&DMAC4.CHSTAT_n, + DMAC4_CHSTAT_n_SR_SHIFT, + DMAC4_CHSTAT_n_SR); + + /* ==== Load ==== */ + if (0 == reg_set) + { + /* ---- Next0 Register Set ---- */ + DMAC4.N0SA_n = src_addr; /* Start address of transfer source */ + DMAC4.N0DA_n = dst_addr; /* Start address of transfer destination */ + DMAC4.N0TB_n = count; /* Total transfer byte count */ + } + else + { + /* ---- Next1 Register Set ---- */ + DMAC4.N1SA_n = src_addr; /* Start address of transfer source */ + DMAC4.N1DA_n = dst_addr; /* Start address of transfer destination */ + DMAC4.N1TB_n = count; /* Total transfer byte count */ + } +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_userdef.c b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_userdef.c new file mode 100644 index 000000000..77c62132d --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_userdef.c @@ -0,0 +1,762 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ +/******************************************************************************* +* File Name : usb1_function_userdef.c +* $Rev: 1116 $ +* $Date:: 2014-07-09 16:29:19 +0900#$ +* Device(s) : RZ/A1H +* Tool-Chain : +* OS : None +* H/W Platform : +* Description : RZ/A1H R7S72100 USB Sample Program +* Operation : +* Limitations : +*******************************************************************************/ + + +/******************************************************************************* +Includes <System Includes> , "Project Includes" +*******************************************************************************/ +#include <stdio.h> +#include "r_typedefs.h" +#include "iodefine.h" +#include "devdrv_usb_function_api.h" +#include "usb1_function_dmacdrv.h" /* common DMAC driver for USB */ + + +/******************************************************************************* +Typedef definitions +*******************************************************************************/ + + +/******************************************************************************* +Macro definitions +*******************************************************************************/ +#define DUMMY_ACCESS OSTM0CNT + +/* #define CACHE_WRITEBACK */ + + +/******************************************************************************* +Imported global variables and functions (from other files) +*******************************************************************************/ +extern int32_t io_cwb(unsigned long start, unsigned long end); + + +/******************************************************************************* +Exported global variables and functions (to be accessed by other files) +*******************************************************************************/ +static void usb1_function_enable_dmac0(uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc); +static void usb1_function_enable_dmac1(uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc); +static void Userdef_USB_usb1_function_delay_10us_2(void); + + +/******************************************************************************* +Private global variables and functions +*******************************************************************************/ + + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_d0fifo_dmaintid +* Description : get D0FIFO DMA Interrupt ID +* Arguments : none +* Return Value : D0FIFO DMA Interrupt ID +*******************************************************************************/ +IRQn_Type Userdef_USB_usb1_function_d0fifo_dmaintid (void) +{ +#if 0 + return DMAINT1_IRQn; +#else + return 0xFFFF; +#endif +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_d1fifo_dmaintid +* Description : get D1FIFO DMA Interrupt ID +* Arguments : none +* Return Value : D1FIFO DMA Interrupt ID +*******************************************************************************/ +IRQn_Type Userdef_USB_usb1_function_d1fifo_dmaintid (void) +{ +#if 0 + return DMAINT1_IRQn; +#else + return 0xFFFF; +#endif +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_attach +* Description : Wait for the software of 1ms. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_attach (void) +{ + printf("\n"); + printf("channel 1 attach device\n"); + printf("\n"); +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_detach +* Description : Wait for the software of 1ms. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_detach (void) +{ + printf("\n"); + printf("channel 1 detach device\n"); + printf("\n"); +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_delay_1ms +* Description : Wait for the software of 1ms. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_delay_1ms (void) +{ + volatile int i; + volatile unsigned long tmp; + + /* + * Wait 1ms (Please change for your MCU). + */ + for (i = 0; i < 1440; ++i) + { + tmp = DUMMY_ACCESS; + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_delay_xms +* Description : Wait for the software in the period of time specified by the +* : argument. +* : Alter this function according to the user's system. +* Arguments : uint32_t msec ; Wait Time (msec) +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_delay_xms (uint32_t msec) +{ + volatile unsigned short i; + + for (i = 0; i < msec; ++i) + { + Userdef_USB_usb1_function_delay_1ms(); + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_delay_10us +* Description : Waits for software for the period specified by the argument. +* : Alter this function according to the user's system. +* Arguments : uint32_t usec ; Wait Time(x 10usec) +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_delay_10us (uint32_t usec) +{ + volatile int i; + + /* Wait 10us (Please change for your MCU) */ + for (i = 0; i < usec; ++i) + { + Userdef_USB_usb1_function_delay_10us_2(); + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_delay_10us_2 +* Description : Waits for software for the period specified by the argument. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +static void Userdef_USB_usb1_function_delay_10us_2 (void) +{ + volatile int i; + volatile unsigned long tmp; + + /* Wait 1us (Please change for your MCU) */ + for (i = 0; i < 14; ++i) + { + tmp = DUMMY_ACCESS; + } +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_delay_500ns +* Description : Wait for software for 500ns. +* : Alter this function according to the user's system. +* Arguments : none +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_delay_500ns (void) +{ + volatile int i; + volatile unsigned long tmp; + + /* Wait 500ns (Please change for your MCU) */ + /* Wait 500ns I clock 266MHz */ + tmp = DUMMY_ACCESS; +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_start_dma +* Description : Enables DMA transfer on the information specified by the argument. +* : Set DMAC register by this function to enable DMA transfer. +* : After executing this function, USB module is set to start DMA +* : transfer. DMA transfer should not wait for DMA transfer complete. +* Arguments : USB_FUNCTION_DMA_t *dma : DMA parameter +* : typedef struct{ +* : uint32_t fifo; FIFO for using +* : uint32_t buffer; Start address of transfer source/destination +* : uint32_t bytes; Transfer size(Byte) +* : uint32_t dir; Transfer direction(0:Buffer->FIFO, 1:FIFO->Buffer) +* : uint32_t size; DMA transfer size +* : } USB_FUNCTION_DMA_t; +* : uint16_t dfacc ; 0 : cycle steal mode +* : 1 : 16byte continuous mode +* : 2 : 32byte continuous mode +* Return Value : none +*******************************************************************************/ +void Userdef_USB_usb1_function_start_dma (USB_FUNCTION_DMA_t * dma, uint16_t dfacc) +{ + uint32_t trncount; + uint32_t src; + uint32_t dst; + uint32_t size; + uint32_t dir; +#ifdef CACHE_WRITEBACK + uint32_t ptr; +#endif + + trncount = dma->bytes; + dir = dma->dir; + + if (dir == USB_FUNCTION_FIFO2BUF) + { + /* DxFIFO determination */ + dst = dma->buffer; +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB201.D1FIFO.UINT32); + } + size = dma->size; + + if (size == 0) + { + src += 3; /* byte access */ + } + else if (size == 1) + { + src += 2; /* short access */ + } + else + { + /* Do Nothing */ + } +#else + size = dma->size; + + if (size == 2) + { + /* 32bit access */ + if (dfacc == 2) + { + /* 32byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB201.D0FIFOB0); + } + else + { + src = (uint32_t)(&USB201.D1FIFOB0); + } + } + else if (dfacc == 1) + { + /* 16byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB201.D0FIFOB0); + } + else + { + src = (uint32_t)(&USB201.D1FIFOB0); + } + } + else + { + /* normal access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB201.D1FIFO.UINT32); + } + } + } + else if (size == 1) + { + /* 16bit access */ + dfacc = 0; /* force normal access */ + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB201.D1FIFO.UINT32); + } + src += 2; /* short access */ + } + else + { + /* 8bit access */ + dfacc = 0; /* force normal access */ + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + src = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + src = (uint32_t)(&USB201.D1FIFO.UINT32); + } + src += 3; /* byte access */ + } +#endif + } + else + { + /* DxFIFO determination */ + src = dma->buffer; +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB201.D1FIFO.UINT32); + } + size = dma->size; + + if (size == 0) + { + dst += 3; /* byte access */ + } + else if (size == 1) + { + dst += 2; /* short access */ + } + else + { + /* Do Nothing */ + } +#else + size = dma->size; + + if (size == 2) + { + /* 32bit access */ + if (dfacc == 2) + { + /* 32byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB201.D0FIFOB0); + } + else + { + dst = (uint32_t)(&USB201.D1FIFOB0); + } + } + else if (dfacc == 1) + { + /* 16byte access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB201.D0FIFOB0); + } + else + { + dst = (uint32_t)(&USB201.D1FIFOB0); + } + } + else + { + /* normal access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB201.D1FIFO.UINT32); + } + } + } + else if (size == 1) + { + /* 16bit access */ + dfacc = 0; /* force normal access */ + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB201.D1FIFO.UINT32); + } + dst += 2; /* short access */ + } + else + { + /* 8bit access */ + dfacc = 0; /* force normal access */ + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + dst = (uint32_t)(&USB201.D0FIFO.UINT32); + } + else + { + dst = (uint32_t)(&USB201.D1FIFO.UINT32); + } + dst += 3; /* byte access */ + } +#endif + } + +#ifdef CACHE_WRITEBACK + ptr = (uint32_t)dma->buffer; + + if ((ptr & 0x20000000ul) == 0) + { + io_cwb((uint32_t)ptr, (uint32_t)(ptr) + trncount); + } +#endif + + if (dma->fifo == USB_FUNCTION_D0FIFO_DMA) + { + usb1_function_enable_dmac0(src, dst, trncount, size, dir, dma->fifo, dfacc); + } + else + { + usb1_function_enable_dmac1(src, dst, trncount, size, dir, dma->fifo, dfacc); + } +} + +/******************************************************************************* +* Function Name: usb1_function_enable_dmac0 +* Description : Enables DMA transfer on the information specified by the argument. +* Arguments : uint32_t src : src address +* : uint32_t dst : dst address +* : uint32_t count : transfer byte +* : uint32_t size : transfer size +* : uint32_t dir : direction +* : uint32_t fifo : FIFO(D0FIFO or D1FIFO) +* : uint16_t dfacc : 0 : normal access +* : : 1 : 16byte access +* : : 2 : 32byte access +* Return Value : none +*******************************************************************************/ +static void usb1_function_enable_dmac0 (uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc) +{ + dmac_transinfo_t trans_info; + uint32_t request_factor = 0; + int32_t ret; + + /* ==== Variable setting for DMAC initialization ==== */ + trans_info.src_addr = (uint32_t)src; /* Start address of transfer source */ + trans_info.dst_addr = (uint32_t)dst; /* Start address of transfer destination */ + trans_info.count = (uint32_t)count; /* Total byte count to be transferred */ +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } +#else + if (dfacc == 2) + { + /* 32byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_256; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_256; /* Transfer destination transfer size */ + } + else if (dfacc == 1) + { + /* 16byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_128; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_128; /* Transfer destination transfer size */ + } + else + { + /* normal access */ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } + } +#endif + + if (dir == USB_FUNCTION_FIFO2BUF) + { + request_factor =DMAC_REQ_USB1_DMA0_RX; /* USB_0 channel 0 receive FIFO full */ + trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer destination address */ + } + else if (dir == USB_FUNCTION_BUF2FIFO) + { + request_factor =DMAC_REQ_USB1_DMA0_TX; /* USB_0 channel 0 receive FIFO empty */ + trans_info.saddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer destination address */ + } + else + { + /* Do Nothing */ + } + + /* ==== DMAC initialization ==== */ + usb1_function_DMAC3_PeriReqInit((const dmac_transinfo_t *)&trans_info, + DMAC_MODE_REGISTER, + DMAC_SAMPLE_SINGLE, + request_factor, + 0); /* Don't care DMAC_REQ_REQD is setting in + usb1_function_DMAC3_PeriReqInit() */ + + /* ==== DMAC startup ==== */ + ret = usb1_function_DMAC3_Open(DMAC_REQ_MODE_PERI); + if (ret != 0) + { + printf("DMAC3 Open error!!\n"); + } + + return; +} + +/******************************************************************************* +* Function Name: usb1_function_enable_dmac1 +* Description : Enables DMA transfer on the information specified by the argument. +* Arguments : uint32_t src : src address +* : uint32_t dst : dst address +* : uint32_t count : transfer byte +* : uint32_t size : transfer size +* : uint32_t dir : direction +* : uint32_t fifo : FIFO(D0FIFO or D1FIFO) +* : uint16_t dfacc : 0 : normal access +* : : 1 : 16byte access +* : : 2 : 32byte access +* Return Value : none +*******************************************************************************/ +static void usb1_function_enable_dmac1 (uint32_t src, uint32_t dst, uint32_t count, + uint32_t size, uint32_t dir, uint32_t fifo, uint16_t dfacc) +{ + dmac_transinfo_t trans_info; + uint32_t request_factor = 0; + int32_t ret; + + /* ==== Variable setting for DMAC initialization ==== */ + trans_info.src_addr = (uint32_t)src; /* Start address of transfer source */ + trans_info.dst_addr = (uint32_t)dst; /* Start address of transfer destination */ + trans_info.count = (uint32_t)count; /* Total byte count to be transferred */ +#ifndef __USB_FUNCTION_DF_ACC_ENABLE__ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } +#else + if (dfacc == 2) + { + /* 32byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_256; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_256; /* Transfer destination transfer size */ + } + else if (dfacc == 1) + { + /* 16byte access */ + trans_info.src_size = DMAC_TRANS_SIZE_128; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_128; /* Transfer destination transfer size */ + } + else + { + /* normal access */ + if (size == 0) + { + trans_info.src_size = DMAC_TRANS_SIZE_8; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_8; /* Transfer destination transfer size */ + } + else if (size == 1) + { + trans_info.src_size = DMAC_TRANS_SIZE_16; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_16; /* Transfer destination transfer size */ + } + else if (size == 2) + { + trans_info.src_size = DMAC_TRANS_SIZE_32; /* Transfer source transfer size */ + trans_info.dst_size = DMAC_TRANS_SIZE_32; /* Transfer destination transfer size */ + } + else + { + printf("size error!!\n"); + } + } +#endif + + if (dir == USB_FUNCTION_FIFO2BUF) + { + request_factor =DMAC_REQ_USB1_DMA1_RX; /* USB_0 channel 0 receive FIFO full */ + trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer destination address */ + } + else if (dir == USB_FUNCTION_BUF2FIFO) + { + request_factor =DMAC_REQ_USB1_DMA1_TX; /* USB_0 channel 0 receive FIFO empty */ + trans_info.saddr_dir = DMAC_TRANS_ADR_INC; /* Count direction of transfer source address */ + trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC; /* Count direction of transfer destination address */ + } + else + { + /* Do Nothing */ + } + + /* ==== DMAC initialization ==== */ + usb1_function_DMAC4_PeriReqInit((const dmac_transinfo_t *)&trans_info, + DMAC_MODE_REGISTER, + DMAC_SAMPLE_SINGLE, + request_factor, + 0); /* Don't care DMAC_REQ_REQD is setting in + usb1_function_DMAC4_PeriReqInit() */ + + /* ==== DMAC startup ==== */ + ret = usb1_function_DMAC4_Open(DMAC_REQ_MODE_PERI); + if (ret != 0) + { + printf("DMAC4 Open error!!\n"); + } + + return; +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_stop_dma0 +* Description : Disables DMA transfer. +* : This function should be executed to DMAC executed at the time +* : of specification of D0_FIF0_DMA in dma->fifo. +* Arguments : none +* Return Value : uint32_t return Transfer Counter register(DMATCRn) value +* : regarding to the bus width. +*******************************************************************************/ +uint32_t Userdef_USB_usb1_function_stop_dma0 (void) +{ + uint32_t remain; + + /* ==== DMAC release ==== */ + usb1_function_DMAC3_Close(&remain); + + return remain; +} + +/******************************************************************************* +* Function Name: Userdef_USB_usb1_function_stop_dma1 +* Description : Disables DMA transfer. +* : This function should be executed to DMAC executed at the time +* : of specification of D1_FIF0_DMA in dma->fifo. +* Arguments : none +* Return Value : uint32_t return Transfer Counter register(DMATCRn) value +* : regarding to the bus width. +*******************************************************************************/ +uint32_t Userdef_USB_usb1_function_stop_dma1 (void) +{ + uint32_t remain; + + /* ==== DMAC release ==== */ + usb1_function_DMAC4_Close(&remain); + + return remain; +} + +/* End of File */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb_function_setting.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb_function_setting.h new file mode 100644 index 000000000..fc940c477 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb_function_setting.h @@ -0,0 +1,173 @@ +/******************************************************************************* +* DISCLAIMER +* This software is supplied by Renesas Electronics Corporation and is only +* intended for use with Renesas products. No other uses are authorized. This +* software is owned by Renesas Electronics Corporation and is protected under +* all applicable laws, including copyright laws. +* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING +* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT +* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE +* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. +* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS +* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE +* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR +* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE +* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +* Renesas reserves the right, without notice, to make changes to this software +* and to discontinue the availability of this software. By using this software, +* you agree to the additional terms and conditions found by accessing the +* following link: +* http://www.renesas.com/disclaimer +* Copyright (C) 2014 - 2015 Renesas Electronics Corporation. All rights reserved. +*******************************************************************************/ + +#ifndef USB_FUNCTION_SETTING_H +#define USB_FUNCTION_SETTING_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define USB_FUNCTION_CH 0 +#define USB_FUNCTION_HISPEED 1 + +#if (USB_FUNCTION_CH == 0) +#include "usb0_function.h" +#define USB20X USB200 +#define USBIX_IRQn USBI0_IRQn +#define g_usbx_function_bit_set g_usb0_function_bit_set +#define g_usbx_function_PipeDataSize g_usb0_function_PipeDataSize +#define g_usbx_function_data_count g_usb0_function_data_count +#define g_usbx_function_PipeTbl g_usb0_function_PipeTbl +#define g_usbx_function_DmaStatus g_usb0_function_DmaStatus +#define g_usbx_function_pipecfg g_usb0_function_pipecfg +#define g_usbx_function_pipe_status g_usb0_function_pipe_status +#define g_usbx_function_data_pointer g_usb0_function_data_pointer +#define g_usbx_function_pipebuf g_usb0_function_pipebuf +#define g_usbx_function_pipemaxp g_usb0_function_pipemaxp +#define g_usbx_function_pipeperi g_usb0_function_pipeperi +#define g_usbx_function_TestModeFlag g_usb0_function_TestModeFlag +#define usbx_function_BRDYInterruptPIPE0 usb0_function_BRDYInterruptPIPE0 +#define usbx_function_BRDYInterrupt usb0_function_BRDYInterrupt +#define usbx_function_NRDYInterruptPIPE0 usb0_function_NRDYInterruptPIPE0 +#define usbx_function_NRDYInterrupt usb0_function_NRDYInterrupt +#define usbx_function_BEMPInterruptPIPE0 usb0_function_BEMPInterruptPIPE0 +#define usbx_function_BEMPInterrupt usb0_function_BEMPInterrupt +#define usbx_function_read_buffer_c usb0_function_read_buffer_c +#define usbx_function_set_pid_buf usb0_function_set_pid_buf +#define usbx_function_disable_brdy_int usb0_function_disable_brdy_int +#define usbx_function_set_pid_stall usb0_function_set_pid_stall +#define usbx_function_dma_interrupt_d0fifo usb0_function_dma_interrupt_d0fifo +#define usbx_function_read_dma usb0_function_read_dma +#define usbx_function_dma_interrupt_d1fifo usb0_function_dma_interrupt_d1fifo +#define usbx_function_write_buffer usb0_function_write_buffer +#define usbx_function_set_pid_nak usb0_function_set_pid_nak +#define usbx_function_get_mbw usb0_function_get_mbw +#define usbx_function_set_curpipe usb0_function_set_curpipe +#define usbx_function_aclrm usb0_function_aclrm +#define usbx_function_enable_nrdy_int usb0_function_enable_nrdy_int +#define usbx_function_enable_brdy_int usb0_function_enable_brdy_int +#define usbx_function_get_pid usb0_function_get_pid +#define usbx_function_get_inbuf usb0_function_get_inbuf +#define usbx_function_disable_bemp_int usb0_function_disable_bemp_int +#define usbx_function_EpToPipe usb0_function_EpToPipe +#define usbx_function_clear_pipe_tbl usb0_function_clear_pipe_tbl +#define Userdef_USB_usbx_function_d0fifo_dmaintid Userdef_USB_usb0_function_d0fifo_dmaintid +#define Userdef_USB_usbx_function_d1fifo_dmaintid Userdef_USB_usb0_function_d1fifo_dmaintid +#define usbx_function_reset_module usb0_function_reset_module +#define usbx_function_init_status usb0_function_init_status +#define usbx_function_InitModule usb0_function_InitModule +#define usbx_function_clear_alt usb0_function_clear_alt +#define usbx_function_set_sqclr usb0_function_set_sqclr +#define usbx_api_function_CtrlWriteStart usb0_api_function_CtrlWriteStart +#define usbx_api_function_CtrlReadStart usb0_api_function_CtrlReadStart +#define usbx_function_write_buffer_c usb0_function_write_buffer_c +#define usbx_api_function_check_pipe_status usb0_api_function_check_pipe_status +#define usbx_api_function_set_pid_nak usb0_api_function_set_pid_nak +#define usbx_api_function_clear_pipe_status usb0_api_function_clear_pipe_status +#define usbx_api_function_start_receive_transfer usb0_api_function_start_receive_transfer +#define usbx_function_read_buffer usb0_function_read_buffer +#define usbx_api_function_start_send_transfer usb0_api_function_start_send_transfer +#define usbx_function_stop_transfer usb0_function_stop_transfer +#define usbx_function_clear_pid_stall usb0_function_clear_pid_stall +#define usbx_function_CheckVBUStaus usb0_function_CheckVBUStaus +#define usbx_function_USB_FUNCTION_Attach usb0_function_USB_FUNCTION_Attach +#define usbx_function_USB_FUNCTION_Detach usb0_function_USB_FUNCTION_Detach +#define usbx_function_is_hispeed usb0_function_is_hispeed +#define usbx_function_ResetDescriptor usb0_function_ResetDescriptor +#define usbx_function_USB_FUNCTION_Suspend usb0_function_USB_FUNCTION_Suspend +#define usbx_function_USB_FUNCTION_TestMode usb0_function_USB_FUNCTION_TestMode +#else +#include "usb1_function.h" +#define USB20X USB201 +#define USBIX_IRQn USBI1_IRQn +#define g_usbx_function_bit_set g_usb1_function_bit_set +#define g_usbx_function_PipeDataSize g_usb1_function_PipeDataSize +#define g_usbx_function_data_count g_usb1_function_data_count +#define g_usbx_function_PipeTbl g_usb1_function_PipeTbl +#define g_usbx_function_DmaStatus g_usb1_function_DmaStatus +#define g_usbx_function_pipecfg g_usb1_function_pipecfg +#define g_usbx_function_pipe_status g_usb1_function_pipe_status +#define g_usbx_function_data_pointer g_usb1_function_data_pointer +#define g_usbx_function_pipebuf g_usb1_function_pipebuf +#define g_usbx_function_pipemaxp g_usb1_function_pipemaxp +#define g_usbx_function_pipeperi g_usb1_function_pipeperi +#define g_usbx_function_TestModeFlag g_usb1_function_TestModeFlag +#define usbx_function_BRDYInterruptPIPE0 usb1_function_BRDYInterruptPIPE0 +#define usbx_function_BRDYInterrupt usb1_function_BRDYInterrupt +#define usbx_function_NRDYInterruptPIPE0 usb1_function_NRDYInterruptPIPE0 +#define usbx_function_NRDYInterrupt usb1_function_NRDYInterrupt +#define usbx_function_BEMPInterruptPIPE0 usb1_function_BEMPInterruptPIPE0 +#define usbx_function_BEMPInterrupt usb1_function_BEMPInterrupt +#define usbx_function_read_buffer_c usb1_function_read_buffer_c +#define usbx_function_set_pid_buf usb1_function_set_pid_buf +#define usbx_function_disable_brdy_int usb1_function_disable_brdy_int +#define usbx_function_set_pid_stall usb1_function_set_pid_stall +#define usbx_function_dma_interrupt_d0fifo usb1_function_dma_interrupt_d0fifo +#define usbx_function_read_dma usb1_function_read_dma +#define usbx_function_dma_interrupt_d1fifo usb1_function_dma_interrupt_d1fifo +#define usbx_function_write_buffer usb1_function_write_buffer +#define usbx_function_set_pid_nak usb1_function_set_pid_nak +#define usbx_function_get_mbw usb1_function_get_mbw +#define usbx_function_set_curpipe usb1_function_set_curpipe +#define usbx_function_aclrm usb1_function_aclrm +#define usbx_function_enable_nrdy_int usb1_function_enable_nrdy_int +#define usbx_function_enable_brdy_int usb1_function_enable_brdy_int +#define usbx_function_get_pid usb1_function_get_pid +#define usbx_function_get_inbuf usb1_function_get_inbuf +#define usbx_function_disable_bemp_int usb1_function_disable_bemp_int +#define usbx_function_EpToPipe usb1_function_EpToPipe +#define usbx_function_clear_pipe_tbl usb1_function_clear_pipe_tbl +#define Userdef_USB_usbx_function_d0fifo_dmaintid Userdef_USB_usb1_function_d0fifo_dmaintid +#define Userdef_USB_usbx_function_d1fifo_dmaintid Userdef_USB_usb1_function_d1fifo_dmaintid +#define usbx_function_reset_module usb1_function_reset_module +#define usbx_function_init_status usb1_function_init_status +#define usbx_function_InitModule usb1_function_InitModule +#define usbx_function_clear_alt usb1_function_clear_alt +#define usbx_function_set_sqclr usb1_function_set_sqclr +#define usbx_api_function_CtrlWriteStart usb1_api_function_CtrlWriteStart +#define usbx_api_function_CtrlReadStart usb1_api_function_CtrlReadStart +#define usbx_function_write_buffer_c usb1_function_write_buffer_c +#define usbx_api_function_check_pipe_status usb1_api_function_check_pipe_status +#define usbx_api_function_set_pid_nak usb1_api_function_set_pid_nak +#define usbx_api_function_clear_pipe_status usb1_api_function_clear_pipe_status +#define usbx_api_function_start_receive_transfer usb1_api_function_start_receive_transfer +#define usbx_function_read_buffer usb1_function_read_buffer +#define usbx_api_function_start_send_transfer usb1_api_function_start_send_transfer +#define usbx_function_stop_transfer usb1_function_stop_transfer +#define usbx_function_clear_pid_stall usb1_function_clear_pid_stall +#define usbx_function_CheckVBUStaus usb1_function_CheckVBUStaus +#define usbx_function_USB_FUNCTION_Attach usb1_function_USB_FUNCTION_Attach +#define usbx_function_USB_FUNCTION_Detach usb1_function_USB_FUNCTION_Detach +#define usbx_function_is_hispeed usb1_function_is_hispeed +#define usbx_function_ResetDescriptor usb1_function_ResetDescriptor +#define usbx_function_USB_FUNCTION_Suspend usb1_function_USB_FUNCTION_Suspend +#define usbx_function_USB_FUNCTION_TestMode usb1_function_USB_FUNCTION_TestMode +#endif + + +#ifdef __cplusplus +} +#endif + +#endif /* USB_FUNCTION_SETTING_H */ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDescriptor.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDescriptor.h new file mode 100644 index 000000000..9d4ce849f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDescriptor.h @@ -0,0 +1,74 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +/* Standard descriptor types */ +#define DEVICE_DESCRIPTOR (1) +#define CONFIGURATION_DESCRIPTOR (2) +#define STRING_DESCRIPTOR (3) +#define INTERFACE_DESCRIPTOR (4) +#define ENDPOINT_DESCRIPTOR (5) +#define QUALIFIER_DESCRIPTOR (6) + +/* Standard descriptor lengths */ +#define DEVICE_DESCRIPTOR_LENGTH (0x12) +#define CONFIGURATION_DESCRIPTOR_LENGTH (0x09) +#define INTERFACE_DESCRIPTOR_LENGTH (0x09) +#define ENDPOINT_DESCRIPTOR_LENGTH (0x07) + + +/*string offset*/ +#define STRING_OFFSET_LANGID (0) +#define STRING_OFFSET_IMANUFACTURER (1) +#define STRING_OFFSET_IPRODUCT (2) +#define STRING_OFFSET_ISERIAL (3) +#define STRING_OFFSET_ICONFIGURATION (4) +#define STRING_OFFSET_IINTERFACE (5) + +/* USB Specification Release Number */ +#define USB_VERSION_2_0 (0x0200) + +/* Least/Most significant byte of short integer */ +#define LSB(n) ((n)&0xff) +#define MSB(n) (((n)&0xff00)>>8) + +/* Convert physical endpoint number to descriptor endpoint number */ +#define PHY_TO_DESC(endpoint) (((endpoint)>>1) | (((endpoint) & 1) ? 0x80:0)) + +/* bmAttributes in configuration descriptor */ +/* C_RESERVED must always be set */ +#define C_RESERVED (1U<<7) +#define C_SELF_POWERED (1U<<6) +#define C_REMOTE_WAKEUP (1U<<5) + +/* bMaxPower in configuration descriptor */ +#define C_POWER(mA) ((mA)/2) + +/* bmAttributes in endpoint descriptor */ +#define E_CONTROL (0x00) +#define E_ISOCHRONOUS (0x01) +#define E_BULK (0x02) +#define E_INTERRUPT (0x03) + +/* For isochronous endpoints only: */ +#define E_NO_SYNCHRONIZATION (0x00) +#define E_ASYNCHRONOUS (0x04) +#define E_ADAPTIVE (0x08) +#define E_SYNCHRONOUS (0x0C) +#define E_DATA (0x00) +#define E_FEEDBACK (0x10) +#define E_IMPLICIT_FEEDBACK (0x20) diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.cpp new file mode 100644 index 000000000..dc3efc96f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.cpp @@ -0,0 +1,1005 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" + +#include "USBEndpoints.h" +#include "USBDevice.h" +#include "USBDescriptor.h" + +//#define DEBUG + +/* Device status */ +#define DEVICE_STATUS_SELF_POWERED (1U<<0) +#define DEVICE_STATUS_REMOTE_WAKEUP (1U<<1) + +/* Endpoint status */ +#define ENDPOINT_STATUS_HALT (1U<<0) + +/* Standard feature selectors */ +#define DEVICE_REMOTE_WAKEUP (1) +#define ENDPOINT_HALT (0) + +/* Macro to convert wIndex endpoint number to physical endpoint number */ +#define WINDEX_TO_PHYSICAL(endpoint) (((endpoint & 0x0f) << 1) + \ + ((endpoint & 0x80) ? 1 : 0)) + + +bool USBDevice::requestGetDescriptor(void) +{ + bool success = false; +#ifdef DEBUG + printf("get descr: type: %d\r\n", DESCRIPTOR_TYPE(transfer.setup.wValue)); +#endif + switch (DESCRIPTOR_TYPE(transfer.setup.wValue)) + { + case DEVICE_DESCRIPTOR: + if (deviceDesc() != NULL) + { + if ((deviceDesc()[0] == DEVICE_DESCRIPTOR_LENGTH) \ + && (deviceDesc()[1] == DEVICE_DESCRIPTOR)) + { +#ifdef DEBUG + printf("device descr\r\n"); +#endif + transfer.remaining = DEVICE_DESCRIPTOR_LENGTH; + transfer.ptr = deviceDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + } + } + break; + case CONFIGURATION_DESCRIPTOR: + if (configurationDesc() != NULL) + { + if ((configurationDesc()[0] == CONFIGURATION_DESCRIPTOR_LENGTH) \ + && (configurationDesc()[1] == CONFIGURATION_DESCRIPTOR)) + { +#ifdef DEBUG + printf("conf descr request\r\n"); +#endif + /* Get wTotalLength */ + transfer.remaining = configurationDesc()[2] \ + | (configurationDesc()[3] << 8); + + transfer.ptr = configurationDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + } + } + break; + case STRING_DESCRIPTOR: +#ifdef DEBUG + printf("str descriptor\r\n"); +#endif + switch (DESCRIPTOR_INDEX(transfer.setup.wValue)) + { + case STRING_OFFSET_LANGID: +#ifdef DEBUG + printf("1\r\n"); +#endif + transfer.remaining = stringLangidDesc()[0]; + transfer.ptr = stringLangidDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + break; + case STRING_OFFSET_IMANUFACTURER: +#ifdef DEBUG + printf("2\r\n"); +#endif + transfer.remaining = stringImanufacturerDesc()[0]; + transfer.ptr = stringImanufacturerDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + break; + case STRING_OFFSET_IPRODUCT: +#ifdef DEBUG + printf("3\r\n"); +#endif + transfer.remaining = stringIproductDesc()[0]; + transfer.ptr = stringIproductDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + break; + case STRING_OFFSET_ISERIAL: +#ifdef DEBUG + printf("4\r\n"); +#endif + transfer.remaining = stringIserialDesc()[0]; + transfer.ptr = stringIserialDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + break; + case STRING_OFFSET_ICONFIGURATION: +#ifdef DEBUG + printf("5\r\n"); +#endif + transfer.remaining = stringIConfigurationDesc()[0]; + transfer.ptr = stringIConfigurationDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + break; + case STRING_OFFSET_IINTERFACE: +#ifdef DEBUG + printf("6\r\n"); +#endif + transfer.remaining = stringIinterfaceDesc()[0]; + transfer.ptr = stringIinterfaceDesc(); + transfer.direction = DEVICE_TO_HOST; + success = true; + break; + } + break; + case INTERFACE_DESCRIPTOR: +#ifdef DEBUG + printf("interface descr\r\n"); +#endif + case ENDPOINT_DESCRIPTOR: +#ifdef DEBUG + printf("endpoint descr\r\n"); +#endif + /* TODO: Support is optional, not implemented here */ + break; + default: +#ifdef DEBUG + printf("ERROR\r\n"); +#endif + break; + } + + return success; +} + +void USBDevice::decodeSetupPacket(uint8_t *data, SETUP_PACKET *packet) +{ + /* Fill in the elements of a SETUP_PACKET structure from raw data */ + packet->bmRequestType.dataTransferDirection = (data[0] & 0x80) >> 7; + packet->bmRequestType.Type = (data[0] & 0x60) >> 5; + packet->bmRequestType.Recipient = data[0] & 0x1f; + packet->bRequest = data[1]; + packet->wValue = (data[2] | (uint16_t)data[3] << 8); + packet->wIndex = (data[4] | (uint16_t)data[5] << 8); + packet->wLength = (data[6] | (uint16_t)data[7] << 8); +} + + +bool USBDevice::controlOut(void) +{ + /* Control transfer data OUT stage */ + uint8_t buffer[MAX_PACKET_SIZE_EP0]; + uint32_t packetSize; + + /* Check we should be transferring data OUT */ + if (transfer.direction != HOST_TO_DEVICE) + { +#if defined(TARGET_KL25Z) | defined(TARGET_KL43Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D5M) | defined(TARGET_K64F) | defined(TARGET_K22F) | defined(TARGET_TEENSY3_1) + /* + * We seem to have a pending device-to-host transfer. The host must have + * sent a new control request without waiting for us to finish processing + * the previous one. This appears to happen when we're connected to certain + * USB 3.0 host chip set. Do a zeor-length send to tell the host we're not + * ready for the new request - that'll make it resend - and then just + * pretend we were successful here so that the pending transfer can finish. + */ + uint8_t buf[1] = { 0 }; + EP0write(buf, 0); + + /* execute our pending ttransfer */ + controlIn(); + + /* indicate success */ + return true; + #else + /* for other platforms, count on the HAL to handle this case */ + return false; + #endif + } + + /* Read from endpoint */ + packetSize = EP0getReadResult(buffer); + + /* Check if transfer size is valid */ + if (packetSize > transfer.remaining) + { + /* Too big */ + return false; + } + + /* Update transfer */ + transfer.ptr += packetSize; + transfer.remaining -= packetSize; + + /* Check if transfer has completed */ + if (transfer.remaining == 0) + { + /* Transfer completed */ + if (transfer.notify) + { + /* Notify class layer. */ + USBCallback_requestCompleted(buffer, packetSize); + transfer.notify = false; + } + /* Status stage */ + EP0write(NULL, 0); + } + else + { + EP0read(); + } + + return true; +} + +bool USBDevice::controlIn(void) +{ + /* Control transfer data IN stage */ + uint32_t packetSize; + + /* Check if transfer has completed (status stage transactions */ + /* also have transfer.remaining == 0) */ + if (transfer.remaining == 0) + { + if (transfer.zlp) + { + /* Send zero length packet */ + EP0write(NULL, 0); + transfer.zlp = false; + } + + /* Transfer completed */ + if (transfer.notify) + { + /* Notify class layer. */ + USBCallback_requestCompleted(NULL, 0); + transfer.notify = false; + } + + EP0read(); + EP0readStage(); + + /* Completed */ + return true; + } + + /* Check we should be transferring data IN */ + if (transfer.direction != DEVICE_TO_HOST) + { + return false; + } + + packetSize = transfer.remaining; + + if (packetSize > MAX_PACKET_SIZE_EP0) + { + packetSize = MAX_PACKET_SIZE_EP0; + } + + /* Write to endpoint */ + EP0write(transfer.ptr, packetSize); + + /* Update transfer */ + transfer.ptr += packetSize; + transfer.remaining -= packetSize; + + return true; +} + +bool USBDevice::requestSetAddress(void) +{ + /* Set the device address */ + setAddress(transfer.setup.wValue); + + if (transfer.setup.wValue == 0) + { + device.state = DEFAULT; + } + else + { + device.state = ADDRESS; + } + + return true; +} + +bool USBDevice::requestSetConfiguration(void) +{ + + device.configuration = transfer.setup.wValue; + /* Set the device configuration */ + if (device.configuration == 0) + { + /* Not configured */ + unconfigureDevice(); + device.state = ADDRESS; + } + else + { + if (USBCallback_setConfiguration(device.configuration)) + { + /* Valid configuration */ + configureDevice(); + device.state = CONFIGURED; + } + else + { + return false; + } + } + + return true; +} + +bool USBDevice::requestGetConfiguration(void) +{ + /* Send the device configuration */ + transfer.ptr = &device.configuration; + transfer.remaining = sizeof(device.configuration); + transfer.direction = DEVICE_TO_HOST; + return true; +} + +bool USBDevice::requestGetInterface(void) +{ + /* Return the selected alternate setting for an interface */ + + if (device.state != CONFIGURED) + { + return false; + } + + /* Send the alternate setting */ + transfer.setup.wIndex = currentInterface; + transfer.ptr = ¤tAlternate; + transfer.remaining = sizeof(currentAlternate); + transfer.direction = DEVICE_TO_HOST; + return true; +} + +bool USBDevice::requestSetInterface(void) +{ + bool success = false; + if(USBCallback_setInterface(transfer.setup.wIndex, transfer.setup.wValue)) + { + success = true; + currentInterface = transfer.setup.wIndex; + currentAlternate = transfer.setup.wValue; + } + return success; +} + +bool USBDevice::requestSetFeature() +{ + bool success = false; + + if (device.state != CONFIGURED) + { + /* Endpoint or interface must be zero */ + if (transfer.setup.wIndex != 0) + { + return false; + } + } + + switch (transfer.setup.bmRequestType.Recipient) + { + case DEVICE_RECIPIENT: + /* TODO: Remote wakeup feature not supported */ + break; + case ENDPOINT_RECIPIENT: + if (transfer.setup.wValue == ENDPOINT_HALT) + { + /* TODO: We should check that the endpoint number is valid */ + stallEndpoint( + WINDEX_TO_PHYSICAL(transfer.setup.wIndex)); + success = true; + } + break; + default: + break; + } + + return success; +} + +bool USBDevice::requestClearFeature() +{ + bool success = false; + + if (device.state != CONFIGURED) + { + /* Endpoint or interface must be zero */ + if (transfer.setup.wIndex != 0) + { + return false; + } + } + + switch (transfer.setup.bmRequestType.Recipient) + { + case DEVICE_RECIPIENT: + /* TODO: Remote wakeup feature not supported */ + break; + case ENDPOINT_RECIPIENT: + /* TODO: We should check that the endpoint number is valid */ + if (transfer.setup.wValue == ENDPOINT_HALT) + { + unstallEndpoint( WINDEX_TO_PHYSICAL(transfer.setup.wIndex)); + success = true; + } + break; + default: + break; + } + + return success; +} + +bool USBDevice::requestGetStatus(void) +{ + static uint16_t status; + bool success = false; + + if (device.state != CONFIGURED) + { + /* Endpoint or interface must be zero */ + if (transfer.setup.wIndex != 0) + { + return false; + } + } + + switch (transfer.setup.bmRequestType.Recipient) + { + case DEVICE_RECIPIENT: + /* TODO: Currently only supports self powered devices */ + status = DEVICE_STATUS_SELF_POWERED; + success = true; + break; + case INTERFACE_RECIPIENT: + status = 0; + success = true; + break; + case ENDPOINT_RECIPIENT: + /* TODO: We should check that the endpoint number is valid */ + if (getEndpointStallState( + WINDEX_TO_PHYSICAL(transfer.setup.wIndex))) + { + status = ENDPOINT_STATUS_HALT; + } + else + { + status = 0; + } + success = true; + break; + default: + break; + } + + if (success) + { + /* Send the status */ + transfer.ptr = (uint8_t *)&status; /* Assumes little endian */ + transfer.remaining = sizeof(status); + transfer.direction = DEVICE_TO_HOST; + } + + return success; +} + +bool USBDevice::requestSetup(void) +{ + bool success = false; + + /* Process standard requests */ + if ((transfer.setup.bmRequestType.Type == STANDARD_TYPE)) + { + switch (transfer.setup.bRequest) + { + case GET_STATUS: + success = requestGetStatus(); + break; + case CLEAR_FEATURE: + success = requestClearFeature(); + break; + case SET_FEATURE: + success = requestSetFeature(); + break; + case SET_ADDRESS: + success = requestSetAddress(); + break; + case GET_DESCRIPTOR: + success = requestGetDescriptor(); + break; + case SET_DESCRIPTOR: + /* TODO: Support is optional, not implemented here */ + success = false; + break; + case GET_CONFIGURATION: + success = requestGetConfiguration(); + break; + case SET_CONFIGURATION: + success = requestSetConfiguration(); + break; + case GET_INTERFACE: + success = requestGetInterface(); + break; + case SET_INTERFACE: + success = requestSetInterface(); + break; + default: + break; + } + } + + return success; +} + +bool USBDevice::controlSetup(void) +{ + bool success = false; + + /* Control transfer setup stage */ + uint8_t buffer[MAX_PACKET_SIZE_EP0]; + + EP0setup(buffer); + + /* Initialise control transfer state */ + decodeSetupPacket(buffer, &transfer.setup); + transfer.ptr = NULL; + transfer.remaining = 0; + transfer.direction = 0; + transfer.zlp = false; + transfer.notify = false; + +#ifdef DEBUG + printf("dataTransferDirection: %d\r\nType: %d\r\nRecipient: %d\r\nbRequest: %d\r\nwValue: %d\r\nwIndex: %d\r\nwLength: %d\r\n",transfer.setup.bmRequestType.dataTransferDirection, + transfer.setup.bmRequestType.Type, + transfer.setup.bmRequestType.Recipient, + transfer.setup.bRequest, + transfer.setup.wValue, + transfer.setup.wIndex, + transfer.setup.wLength); +#endif + + /* Class / vendor specific */ + success = USBCallback_request(); + + if (!success) + { + /* Standard requests */ + if (!requestSetup()) + { +#ifdef DEBUG + printf("fail!!!!\r\n"); +#endif + return false; + } + } + + /* Check transfer size and direction */ + if (transfer.setup.wLength>0) + { + if (transfer.setup.bmRequestType.dataTransferDirection \ + == DEVICE_TO_HOST) + { + /* IN data stage is required */ + if (transfer.direction != DEVICE_TO_HOST) + { + return false; + } + + /* Transfer must be less than or equal to the size */ + /* requested by the host */ + if (transfer.remaining > transfer.setup.wLength) + { + transfer.remaining = transfer.setup.wLength; + } + } + else + { + + /* OUT data stage is required */ + if (transfer.direction != HOST_TO_DEVICE) + { + return false; + } + + /* Transfer must be equal to the size requested by the host */ + if (transfer.remaining != transfer.setup.wLength) + { + return false; + } + } + } + else + { + /* No data stage; transfer size must be zero */ + if (transfer.remaining != 0) + { + return false; + } + } + + /* Data or status stage if applicable */ + if (transfer.setup.wLength>0) + { + if (transfer.setup.bmRequestType.dataTransferDirection \ + == DEVICE_TO_HOST) + { + /* Check if we'll need to send a zero length packet at */ + /* the end of this transfer */ + if (transfer.setup.wLength > transfer.remaining) + { + /* Device wishes to transfer less than host requested */ + if ((transfer.remaining % MAX_PACKET_SIZE_EP0) == 0) + { + /* Transfer is a multiple of EP0 max packet size */ + transfer.zlp = true; + } + } + + /* IN stage */ + controlIn(); + } + else + { + /* OUT stage */ + EP0read(); + } + } + else + { + /* Status stage */ + EP0write(NULL, 0); + } + + return true; +} + +void USBDevice::busReset(void) +{ + device.state = DEFAULT; + device.configuration = 0; + device.suspended = false; + + /* Call class / vendor specific busReset function */ + USBCallback_busReset(); +} + +void USBDevice::EP0setupCallback(void) +{ + /* Endpoint 0 setup event */ + if (!controlSetup()) + { + /* Protocol stall */ + EP0stall(); + } + + /* Return true if an OUT data stage is expected */ +} + +void USBDevice::EP0out(void) +{ + /* Endpoint 0 OUT data event */ + if (!controlOut()) + { + /* Protocol stall; this will stall both endpoints */ + EP0stall(); + } +} + +void USBDevice::EP0in(void) +{ +#ifdef DEBUG + printf("EP0IN\r\n"); +#endif + /* Endpoint 0 IN data event */ + if (!controlIn()) + { + /* Protocol stall; this will stall both endpoints */ + EP0stall(); + } +} + +bool USBDevice::configured(void) +{ + /* Returns true if device is in the CONFIGURED state */ + return (device.state == CONFIGURED); +} + +void USBDevice::connect(bool blocking) +{ + /* Connect device */ + USBHAL::connect(); + + if (blocking) { + /* Block if not configured */ + while (!configured()); + } +} + +void USBDevice::disconnect(void) +{ + /* Disconnect device */ + USBHAL::disconnect(); + + /* Set initial device state */ + device.state = POWERED; + device.configuration = 0; + device.suspended = false; +} + +CONTROL_TRANSFER * USBDevice::getTransferPtr(void) +{ + return &transfer; +} + +bool USBDevice::addEndpoint(uint8_t endpoint, uint32_t maxPacket) +{ + return realiseEndpoint(endpoint, maxPacket, 0); +} + +bool USBDevice::addRateFeedbackEndpoint(uint8_t endpoint, uint32_t maxPacket) +{ + /* For interrupt endpoints only */ + return realiseEndpoint(endpoint, maxPacket, RATE_FEEDBACK_MODE); +} + +uint8_t * USBDevice::findDescriptor(uint8_t descriptorType) +{ + /* Find a descriptor within the list of descriptors */ + /* following a configuration descriptor. */ + uint16_t wTotalLength; + uint8_t *ptr; + + if (configurationDesc() == NULL) + { + return NULL; + } + + /* Check this is a configuration descriptor */ + if ((configurationDesc()[0] != CONFIGURATION_DESCRIPTOR_LENGTH) \ + || (configurationDesc()[1] != CONFIGURATION_DESCRIPTOR)) + { + return NULL; + } + + wTotalLength = configurationDesc()[2] | (configurationDesc()[3] << 8); + + /* Check there are some more descriptors to follow */ + if (wTotalLength <= (CONFIGURATION_DESCRIPTOR_LENGTH+2)) + /* +2 is for bLength and bDescriptorType of next descriptor */ + { + return NULL; + } + + /* Start at first descriptor after the configuration descriptor */ + ptr = &(configurationDesc()[CONFIGURATION_DESCRIPTOR_LENGTH]); + + do { + if (ptr[1] /* bDescriptorType */ == descriptorType) + { + /* Found */ + return ptr; + } + + /* Skip to next descriptor */ + ptr += ptr[0]; /* bLength */ + } while (ptr < (configurationDesc() + wTotalLength)); + + /* Reached end of the descriptors - not found */ + return NULL; +} + + +void USBDevice::connectStateChanged(unsigned int connected) +{ +} + +void USBDevice::suspendStateChanged(unsigned int suspended) +{ +} + + +USBDevice::USBDevice(uint16_t vendor_id, uint16_t product_id, uint16_t product_release){ + VENDOR_ID = vendor_id; + PRODUCT_ID = product_id; + PRODUCT_RELEASE = product_release; + + /* Set initial device state */ + device.state = POWERED; + device.configuration = 0; + device.suspended = false; +}; + + +bool USBDevice::readStart(uint8_t endpoint, uint32_t maxSize) +{ + return endpointRead(endpoint, maxSize) == EP_PENDING; +} + + +bool USBDevice::write(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize) +{ + EP_STATUS result; + + if (size > maxSize) + { + return false; + } + + + if(!configured()) { + return false; + } + + /* Send report */ + result = endpointWrite(endpoint, buffer, size); + + if (result != EP_PENDING) + { + return false; + } + + /* Wait for completion */ + do { + result = endpointWriteResult(endpoint); + } while ((result == EP_PENDING) && configured()); + + return (result == EP_COMPLETED); +} + + +bool USBDevice::writeNB(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize) +{ + EP_STATUS result; + + if (size > maxSize) + { + return false; + } + + if(!configured()) { + return false; + } + + /* Send report */ + result = endpointWrite(endpoint, buffer, size); + + if (result != EP_PENDING) + { + return false; + } + + result = endpointWriteResult(endpoint); + + return (result == EP_COMPLETED); +} + + + +bool USBDevice::readEP(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize) +{ + EP_STATUS result; + + if(!configured()) { + return false; + } + + /* Wait for completion */ + do { + result = endpointReadResult(endpoint, buffer, size); + } while ((result == EP_PENDING) && configured()); + + return (result == EP_COMPLETED); +} + + +bool USBDevice::readEP_NB(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize) +{ + EP_STATUS result; + + if(!configured()) { + return false; + } + + result = endpointReadResult(endpoint, buffer, size); + + return (result == EP_COMPLETED); +} + + + +uint8_t * USBDevice::deviceDesc() { + static uint8_t deviceDescriptor[] = { + DEVICE_DESCRIPTOR_LENGTH, /* bLength */ + DEVICE_DESCRIPTOR, /* bDescriptorType */ + LSB(USB_VERSION_2_0), /* bcdUSB (LSB) */ + MSB(USB_VERSION_2_0), /* bcdUSB (MSB) */ + 0x00, /* bDeviceClass */ + 0x00, /* bDeviceSubClass */ + 0x00, /* bDeviceprotocol */ + MAX_PACKET_SIZE_EP0, /* bMaxPacketSize0 */ + (uint8_t)(LSB(VENDOR_ID)), /* idVendor (LSB) */ + (uint8_t)(MSB(VENDOR_ID)), /* idVendor (MSB) */ + (uint8_t)(LSB(PRODUCT_ID)), /* idProduct (LSB) */ + (uint8_t)(MSB(PRODUCT_ID)), /* idProduct (MSB) */ + (uint8_t)(LSB(PRODUCT_RELEASE)), /* bcdDevice (LSB) */ + (uint8_t)(MSB(PRODUCT_RELEASE)), /* bcdDevice (MSB) */ + STRING_OFFSET_IMANUFACTURER, /* iManufacturer */ + STRING_OFFSET_IPRODUCT, /* iProduct */ + STRING_OFFSET_ISERIAL, /* iSerialNumber */ + 0x01 /* bNumConfigurations */ + }; + return deviceDescriptor; +} + +uint8_t * USBDevice::stringLangidDesc() { + static uint8_t stringLangidDescriptor[] = { + 0x04, /*bLength*/ + STRING_DESCRIPTOR, /*bDescriptorType 0x03*/ + 0x09,0x04, /*bString Lang ID - 0x0409 - English*/ + }; + return stringLangidDescriptor; +} + +uint8_t * USBDevice::stringImanufacturerDesc() { + static uint8_t stringImanufacturerDescriptor[] = { + 0x12, /*bLength*/ + STRING_DESCRIPTOR, /*bDescriptorType 0x03*/ + 'm',0,'b',0,'e',0,'d',0,'.',0,'o',0,'r',0,'g',0, /*bString iManufacturer - mbed.org*/ + }; + return stringImanufacturerDescriptor; +} + +uint8_t * USBDevice::stringIserialDesc() { + static uint8_t stringIserialDescriptor[] = { + 0x16, /*bLength*/ + STRING_DESCRIPTOR, /*bDescriptorType 0x03*/ + '0',0,'1',0,'2',0,'3',0,'4',0,'5',0,'6',0,'7',0,'8',0,'9',0, /*bString iSerial - 0123456789*/ + }; + return stringIserialDescriptor; +} + +uint8_t * USBDevice::stringIConfigurationDesc() { + static uint8_t stringIconfigurationDescriptor[] = { + 0x06, /*bLength*/ + STRING_DESCRIPTOR, /*bDescriptorType 0x03*/ + '0',0,'1',0, /*bString iConfiguration - 01*/ + }; + return stringIconfigurationDescriptor; +} + +uint8_t * USBDevice::stringIinterfaceDesc() { + static uint8_t stringIinterfaceDescriptor[] = { + 0x08, /*bLength*/ + STRING_DESCRIPTOR, /*bDescriptorType 0x03*/ + 'U',0,'S',0,'B',0, /*bString iInterface - USB*/ + }; + return stringIinterfaceDescriptor; +} + +uint8_t * USBDevice::stringIproductDesc() { + static uint8_t stringIproductDescriptor[] = { + 0x16, /*bLength*/ + STRING_DESCRIPTOR, /*bDescriptorType 0x03*/ + 'U',0,'S',0,'B',0,' ',0,'D',0,'E',0,'V',0,'I',0,'C',0,'E',0 /*bString iProduct - USB DEVICE*/ + }; + return stringIproductDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.h new file mode 100644 index 000000000..a25ca1adf --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.h @@ -0,0 +1,271 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBDEVICE_H +#define USBDEVICE_H + +#include "mbed.h" +#include "USBDevice_Types.h" +#include "USBHAL.h" + +class USBDevice: public USBHAL +{ +public: + USBDevice(uint16_t vendor_id, uint16_t product_id, uint16_t product_release); + + /* + * Check if the device is configured + * + * @returns true if configured, false otherwise + */ + bool configured(void); + + /* + * Connect a device + * + * @param blocking: block if not configured + */ + void connect(bool blocking = true); + + /* + * Disconnect a device + */ + void disconnect(void); + + /* + * Add an endpoint + * + * @param endpoint endpoint which will be added + * @param maxPacket Maximum size of a packet which can be sent for this endpoint + * @returns true if successful, false otherwise + */ + bool addEndpoint(uint8_t endpoint, uint32_t maxPacket); + + /* + * Start a reading on a certain endpoint. + * You can access the result of the reading by USBDevice_read + * + * @param endpoint endpoint which will be read + * @param maxSize the maximum length that can be read + * @return true if successful + */ + bool readStart(uint8_t endpoint, uint32_t maxSize); + + /* + * Read a certain endpoint. Before calling this function, USBUSBDevice_readStart + * must be called. + * + * Warning: blocking + * + * @param endpoint endpoint which will be read + * @param buffer buffer will be filled with the data received + * @param size the number of bytes read will be stored in *size + * @param maxSize the maximum length that can be read + * @returns true if successful + */ + bool readEP(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize); + + /* + * Read a certain endpoint. + * + * Warning: non blocking + * + * @param endpoint endpoint which will be read + * @param buffer buffer will be filled with the data received (if data are available) + * @param size the number of bytes read will be stored in *size + * @param maxSize the maximum length that can be read + * @returns true if successful + */ + bool readEP_NB(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize); + + /* + * Write a certain endpoint. + * + * Warning: blocking + * + * @param endpoint endpoint to write + * @param buffer data contained in buffer will be write + * @param size the number of bytes to write + * @param maxSize the maximum length that can be written on this endpoint + */ + bool write(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize); + + + /* + * Write a certain endpoint. + * + * Warning: non blocking + * + * @param endpoint endpoint to write + * @param buffer data contained in buffer will be write + * @param size the number of bytes to write + * @param maxSize the maximum length that can be written on this endpoint + */ + bool writeNB(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize); + + + /* + * Called by USBDevice layer on bus reset. Warning: Called in ISR context + * + * May be used to reset state + */ + virtual void USBCallback_busReset(void) {}; + + /* + * Called by USBDevice on Endpoint0 request. Warning: Called in ISR context + * This is used to handle extensions to standard requests + * and class specific requests + * + * @returns true if class handles this request + */ + virtual bool USBCallback_request() { return false; }; + + /* + * Called by USBDevice on Endpoint0 request completion + * if the 'notify' flag has been set to true. Warning: Called in ISR context + * + * In this case it is used to indicate that a HID report has + * been received from the host on endpoint 0 + * + * @param buf buffer received on endpoint 0 + * @param length length of this buffer + */ + virtual void USBCallback_requestCompleted(uint8_t * buf, uint32_t length) {}; + + /* + * Called by USBDevice layer. Set configuration of the device. + * For instance, you can add all endpoints that you need on this function. + * + * @param configuration Number of the configuration + */ + virtual bool USBCallback_setConfiguration(uint8_t configuration) { return false; }; + + /* + * Called by USBDevice layer. Set interface/alternate of the device. + * + * @param interface Number of the interface to be configured + * @param alternate Number of the alternate to be configured + * @returns true if class handles this request + */ + virtual bool USBCallback_setInterface(uint16_t interface, uint8_t alternate) { return false; }; + + /* + * Get device descriptor. Warning: this method has to store the length of the report descriptor in reportLength. + * + * @returns pointer to the device descriptor + */ + virtual uint8_t * deviceDesc(); + + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(){return NULL;}; + + /* + * Get string lang id descriptor + * + * @return pointer to the string lang id descriptor + */ + virtual uint8_t * stringLangidDesc(); + + /* + * Get string manufacturer descriptor + * + * @returns pointer to the string manufacturer descriptor + */ + virtual uint8_t * stringImanufacturerDesc(); + + /* + * Get string product descriptor + * + * @returns pointer to the string product descriptor + */ + virtual uint8_t * stringIproductDesc(); + + /* + * Get string serial descriptor + * + * @returns pointer to the string serial descriptor + */ + virtual uint8_t * stringIserialDesc(); + + /* + * Get string configuration descriptor + * + * @returns pointer to the string configuration descriptor + */ + virtual uint8_t * stringIConfigurationDesc(); + + /* + * Get string interface descriptor + * + * @returns pointer to the string interface descriptor + */ + virtual uint8_t * stringIinterfaceDesc(); + + /* + * Get the length of the report descriptor + * + * @returns length of the report descriptor + */ + virtual uint16_t reportDescLength() { return 0; }; + + + +protected: + virtual void busReset(void); + virtual void EP0setupCallback(void); + virtual void EP0out(void); + virtual void EP0in(void); + virtual void connectStateChanged(unsigned int connected); + virtual void suspendStateChanged(unsigned int suspended); + uint8_t * findDescriptor(uint8_t descriptorType); + CONTROL_TRANSFER * getTransferPtr(void); + + uint16_t VENDOR_ID; + uint16_t PRODUCT_ID; + uint16_t PRODUCT_RELEASE; + +private: + bool addRateFeedbackEndpoint(uint8_t endpoint, uint32_t maxPacket); + bool requestGetDescriptor(void); + bool controlOut(void); + bool controlIn(void); + bool requestSetAddress(void); + bool requestSetConfiguration(void); + bool requestSetFeature(void); + bool requestClearFeature(void); + bool requestGetStatus(void); + bool requestSetup(void); + bool controlSetup(void); + void decodeSetupPacket(uint8_t *data, SETUP_PACKET *packet); + bool requestGetConfiguration(void); + bool requestGetInterface(void); + bool requestSetInterface(void); + + CONTROL_TRANSFER transfer; + USB_DEVICE device; + + uint16_t currentInterface; + uint8_t currentAlternate; +}; + + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice_Types.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice_Types.h new file mode 100644 index 000000000..19bc1c2f3 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice_Types.h @@ -0,0 +1,83 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBDEVICE_TYPES_H +#define USBDEVICE_TYPES_H + +/* Standard requests */ +#define GET_STATUS (0) +#define CLEAR_FEATURE (1) +#define SET_FEATURE (3) +#define SET_ADDRESS (5) +#define GET_DESCRIPTOR (6) +#define SET_DESCRIPTOR (7) +#define GET_CONFIGURATION (8) +#define SET_CONFIGURATION (9) +#define GET_INTERFACE (10) +#define SET_INTERFACE (11) + +/* bmRequestType.dataTransferDirection */ +#define HOST_TO_DEVICE (0) +#define DEVICE_TO_HOST (1) + +/* bmRequestType.Type*/ +#define STANDARD_TYPE (0) +#define CLASS_TYPE (1) +#define VENDOR_TYPE (2) +#define RESERVED_TYPE (3) + +/* bmRequestType.Recipient */ +#define DEVICE_RECIPIENT (0) +#define INTERFACE_RECIPIENT (1) +#define ENDPOINT_RECIPIENT (2) +#define OTHER_RECIPIENT (3) + +/* Descriptors */ +#define DESCRIPTOR_TYPE(wValue) (wValue >> 8) +#define DESCRIPTOR_INDEX(wValue) (wValue & 0xff) + +typedef struct { + struct { + uint8_t dataTransferDirection; + uint8_t Type; + uint8_t Recipient; + } bmRequestType; + uint8_t bRequest; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} SETUP_PACKET; + +typedef struct { + SETUP_PACKET setup; + uint8_t *ptr; + uint32_t remaining; + uint8_t direction; + bool zlp; + bool notify; +} CONTROL_TRANSFER; + +typedef enum {ATTACHED, POWERED, DEFAULT, ADDRESS, CONFIGURED} DEVICE_STATE; + +typedef struct { + volatile DEVICE_STATE state; + uint8_t configuration; + bool suspended; +} USB_DEVICE; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints.h new file mode 100644 index 000000000..48950986a --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints.h @@ -0,0 +1,56 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBENDPOINTS_H +#define USBENDPOINTS_H + +/* SETUP packet size */ +#define SETUP_PACKET_SIZE (8) + +/* Options flags for configuring endpoints */ +#define DEFAULT_OPTIONS (0) +#define SINGLE_BUFFERED (1U << 0) +#define ISOCHRONOUS (1U << 1) +#define RATE_FEEDBACK_MODE (1U << 2) /* Interrupt endpoints only */ + +/* Endpoint transfer status, for endpoints > 0 */ +typedef enum { + EP_COMPLETED, /* Transfer completed */ + EP_PENDING, /* Transfer in progress */ + EP_INVALID, /* Invalid parameter */ + EP_STALLED, /* Endpoint stalled */ +} EP_STATUS; + +/* Include configuration for specific target */ +#if defined(TARGET_LPC1768) || defined(TARGET_LPC2368) || defined(TARGET_LPC4088) || defined(TARGET_LPC4088_DM) +#include "USBEndpoints_LPC17_LPC23.h" +#elif defined(TARGET_LPC11UXX) || defined(TARGET_LPC1347) || defined (TARGET_LPC11U6X) || defined (TARGET_LPC1549) +#include "USBEndpoints_LPC11U.h" +#elif defined(TARGET_KL25Z) | defined(TARGET_KL43Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D50M) | defined(TARGET_K64F) | defined(TARGET_K22F) | defined(TARGET_TEENSY3_1) +#include "USBEndpoints_KL25Z.h" +#elif defined (TARGET_STM32F4) +#include "USBEndpoints_STM32F4.h" +#elif defined (TARGET_RZ_A1H) +#include "USBEndpoints_RZ_A1H.h" +#elif defined(TARGET_Maxim) +#include "USBEndpoints_Maxim.h" +#else +#error "Unknown target type" +#endif + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_KL25Z.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_KL25Z.h new file mode 100644 index 000000000..87721a21c --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_KL25Z.h @@ -0,0 +1,99 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#define NUMBER_OF_LOGICAL_ENDPOINTS (16) +#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2) + +/* Define physical endpoint numbers */ + +/* Endpoint No. */ +/* ---------------- */ +#define EP0OUT (0) +#define EP0IN (1) +#define EP1OUT (2) +#define EP1IN (3) +#define EP2OUT (4) +#define EP2IN (5) +#define EP3OUT (6) +#define EP3IN (7) +#define EP4OUT (8) +#define EP4IN (9) +#define EP5OUT (10) +#define EP5IN (11) +#define EP6OUT (12) +#define EP6IN (13) +#define EP7OUT (14) +#define EP7IN (15) +#define EP8OUT (16) +#define EP8IN (17) +#define EP9OUT (18) +#define EP9IN (19) +#define EP10OUT (20) +#define EP10IN (21) +#define EP11OUT (22) +#define EP11IN (23) +#define EP12OUT (24) +#define EP12IN (25) +#define EP13OUT (26) +#define EP13IN (27) +#define EP14OUT (28) +#define EP14IN (29) +#define EP15OUT (30) +#define EP15IN (31) + +/* Maximum Packet sizes */ + +#define MAX_PACKET_SIZE_EP0 (64) +#define MAX_PACKET_SIZE_EP1 (64) +#define MAX_PACKET_SIZE_EP2 (64) +#define MAX_PACKET_SIZE_EP3 (1023) +#define MAX_PACKET_SIZE_EP4 (64) +#define MAX_PACKET_SIZE_EP5 (64) +#define MAX_PACKET_SIZE_EP6 (64) +#define MAX_PACKET_SIZE_EP7 (64) +#define MAX_PACKET_SIZE_EP8 (64) +#define MAX_PACKET_SIZE_EP9 (64) +#define MAX_PACKET_SIZE_EP10 (64) +#define MAX_PACKET_SIZE_EP11 (64) +#define MAX_PACKET_SIZE_EP12 (64) +#define MAX_PACKET_SIZE_EP13 (64) +#define MAX_PACKET_SIZE_EP14 (64) +#define MAX_PACKET_SIZE_EP15 (64) + +/* Generic endpoints - intended to be portable accross devices */ +/* and be suitable for simple USB devices. */ + +/* Bulk endpoints */ +#define EPBULK_OUT (EP2OUT) +#define EPBULK_IN (EP2IN) +#define EPBULK_OUT_callback EP2_OUT_callback +#define EPBULK_IN_callback EP2_IN_callback +/* Interrupt endpoints */ +#define EPINT_OUT (EP1OUT) +#define EPINT_IN (EP1IN) +#define EPINT_OUT_callback EP1_OUT_callback +#define EPINT_IN_callback EP1_IN_callback +/* Isochronous endpoints */ +#define EPISO_OUT (EP3OUT) +#define EPISO_IN (EP3IN) +#define EPISO_OUT_callback EP3_OUT_callback +#define EPISO_IN_callback EP3_IN_callback + +#define MAX_PACKET_SIZE_EPBULK (MAX_PACKET_SIZE_EP2) +#define MAX_PACKET_SIZE_EPINT (MAX_PACKET_SIZE_EP1) +#define MAX_PACKET_SIZE_EPISO (MAX_PACKET_SIZE_EP3) diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC11U.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC11U.h new file mode 100644 index 000000000..b4ddaa514 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC11U.h @@ -0,0 +1,71 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#define NUMBER_OF_LOGICAL_ENDPOINTS (5) +#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2) + +/* Define physical endpoint numbers */ + +/* Endpoint No. Type(s) MaxPacket DoubleBuffer */ +/* ---------------- ------------ ---------- --- */ +#define EP0OUT (0) /* Control 64 No */ +#define EP0IN (1) /* Control 64 No */ +#define EP1OUT (2) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP1IN (3) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP2OUT (4) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP2IN (5) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP3OUT (6) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP3IN (7) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP4OUT (8) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP4IN (9) /* Int/Bulk/Iso 64/64/1023 Yes */ + +/* Maximum Packet sizes */ + +#define MAX_PACKET_SIZE_EP0 (64) +#define MAX_PACKET_SIZE_EP1 (64) /* Int/Bulk */ +#define MAX_PACKET_SIZE_EP2 (64) /* Int/Bulk */ +#define MAX_PACKET_SIZE_EP3 (64) /* Int/Bulk */ +#define MAX_PACKET_SIZE_EP4 (64) /* Int/Bulk */ + +#define MAX_PACKET_SIZE_EP1_ISO (1023) /* Isochronous */ +#define MAX_PACKET_SIZE_EP2_ISO (1023) /* Isochronous */ +#define MAX_PACKET_SIZE_EP3_ISO (1023) /* Isochronous */ +#define MAX_PACKET_SIZE_EP4_ISO (1023) /* Isochronous */ + +/* Generic endpoints - intended to be portable accross devices */ +/* and be suitable for simple USB devices. */ + +/* Bulk endpoint */ +#define EPBULK_OUT (EP2OUT) +#define EPBULK_IN (EP2IN) +#define EPBULK_OUT_callback EP2_OUT_callback +#define EPBULK_IN_callback EP2_IN_callback +/* Interrupt endpoint */ +#define EPINT_OUT (EP1OUT) +#define EPINT_IN (EP1IN) +#define EPINT_OUT_callback EP1_OUT_callback +#define EPINT_IN_callback EP1_IN_callback +/* Isochronous endpoint */ +#define EPISO_OUT (EP3OUT) +#define EPISO_IN (EP3IN) +#define EPISO_OUT_callback EP3_OUT_callback +#define EPISO_IN_callback EP3_IN_callback + +#define MAX_PACKET_SIZE_EPBULK (MAX_PACKET_SIZE_EP2) +#define MAX_PACKET_SIZE_EPINT (MAX_PACKET_SIZE_EP1) +#define MAX_PACKET_SIZE_EPISO (MAX_PACKET_SIZE_EP3_ISO) diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC17_LPC23.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC17_LPC23.h new file mode 100644 index 000000000..383b7e36f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC17_LPC23.h @@ -0,0 +1,99 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#define NUMBER_OF_LOGICAL_ENDPOINTS (16) +#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2) + +/* Define physical endpoint numbers */ + +/* Endpoint No. Type(s) MaxPacket DoubleBuffer */ +/* ---------------- ------------ ---------- --- */ +#define EP0OUT (0) /* Control 64 No */ +#define EP0IN (1) /* Control 64 No */ +#define EP1OUT (2) /* Interrupt 64 No */ +#define EP1IN (3) /* Interrupt 64 No */ +#define EP2OUT (4) /* Bulk 64 Yes */ +#define EP2IN (5) /* Bulk 64 Yes */ +#define EP3OUT (6) /* Isochronous 1023 Yes */ +#define EP3IN (7) /* Isochronous 1023 Yes */ +#define EP4OUT (8) /* Interrupt 64 No */ +#define EP4IN (9) /* Interrupt 64 No */ +#define EP5OUT (10) /* Bulk 64 Yes */ +#define EP5IN (11) /* Bulk 64 Yes */ +#define EP6OUT (12) /* Isochronous 1023 Yes */ +#define EP6IN (13) /* Isochronous 1023 Yes */ +#define EP7OUT (14) /* Interrupt 64 No */ +#define EP7IN (15) /* Interrupt 64 No */ +#define EP8OUT (16) /* Bulk 64 Yes */ +#define EP8IN (17) /* Bulk 64 Yes */ +#define EP9OUT (18) /* Isochronous 1023 Yes */ +#define EP9IN (19) /* Isochronous 1023 Yes */ +#define EP10OUT (20) /* Interrupt 64 No */ +#define EP10IN (21) /* Interrupt 64 No */ +#define EP11OUT (22) /* Bulk 64 Yes */ +#define EP11IN (23) /* Bulk 64 Yes */ +#define EP12OUT (24) /* Isochronous 1023 Yes */ +#define EP12IN (25) /* Isochronous 1023 Yes */ +#define EP13OUT (26) /* Interrupt 64 No */ +#define EP13IN (27) /* Interrupt 64 No */ +#define EP14OUT (28) /* Bulk 64 Yes */ +#define EP14IN (29) /* Bulk 64 Yes */ +#define EP15OUT (30) /* Bulk 64 Yes */ +#define EP15IN (31) /* Bulk 64 Yes */ + +/* Maximum Packet sizes */ + +#define MAX_PACKET_SIZE_EP0 (64) +#define MAX_PACKET_SIZE_EP1 (64) +#define MAX_PACKET_SIZE_EP2 (64) +#define MAX_PACKET_SIZE_EP3 (1023) +#define MAX_PACKET_SIZE_EP4 (64) +#define MAX_PACKET_SIZE_EP5 (64) +#define MAX_PACKET_SIZE_EP6 (1023) +#define MAX_PACKET_SIZE_EP7 (64) +#define MAX_PACKET_SIZE_EP8 (64) +#define MAX_PACKET_SIZE_EP9 (1023) +#define MAX_PACKET_SIZE_EP10 (64) +#define MAX_PACKET_SIZE_EP11 (64) +#define MAX_PACKET_SIZE_EP12 (1023) +#define MAX_PACKET_SIZE_EP13 (64) +#define MAX_PACKET_SIZE_EP14 (64) +#define MAX_PACKET_SIZE_EP15 (64) + +/* Generic endpoints - intended to be portable accross devices */ +/* and be suitable for simple USB devices. */ + +/* Bulk endpoints */ +#define EPBULK_OUT (EP2OUT) +#define EPBULK_IN (EP2IN) +#define EPBULK_OUT_callback EP2_OUT_callback +#define EPBULK_IN_callback EP2_IN_callback +/* Interrupt endpoints */ +#define EPINT_OUT (EP1OUT) +#define EPINT_IN (EP1IN) +#define EPINT_OUT_callback EP1_OUT_callback +#define EPINT_IN_callback EP1_IN_callback +/* Isochronous endpoints */ +#define EPISO_OUT (EP3OUT) +#define EPISO_IN (EP3IN) +#define EPISO_OUT_callback EP3_OUT_callback +#define EPISO_IN_callback EP3_IN_callback + +#define MAX_PACKET_SIZE_EPBULK (MAX_PACKET_SIZE_EP2) +#define MAX_PACKET_SIZE_EPINT (MAX_PACKET_SIZE_EP1) +#define MAX_PACKET_SIZE_EPISO (MAX_PACKET_SIZE_EP3) diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_Maxim.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_Maxim.h new file mode 100644 index 000000000..5cd3905c9 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_Maxim.h @@ -0,0 +1,90 @@ +/******************************************************************************* + * Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#define NUMBER_OF_LOGICAL_ENDPOINTS (8) +#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2) + +#define DIR_OUT 0x00 +#define DIR_IN 0x01 +#define EP_NUM(ep) (ep >> 1) +#define IN_EP(ep) (ep & DIR_IN) +#define OUT_EP(ep) (!(ep & DIR_IN)) + +/* Define physical endpoint numbers */ + +/* Endpoint No. */ +/* ---------------- */ +#define EP0OUT ((0 << 1) | DIR_OUT) +#define EP0IN ((0 << 1) | DIR_IN) +#define EP1OUT ((1 << 1) | DIR_OUT) +#define EP1IN ((1 << 1) | DIR_IN) +#define EP2OUT ((2 << 1) | DIR_OUT) +#define EP2IN ((2 << 1) | DIR_IN) +#define EP3OUT ((3 << 1) | DIR_OUT) +#define EP3IN ((3 << 1) | DIR_IN) +#define EP4OUT ((4 << 1) | DIR_OUT) +#define EP4IN ((4 << 1) | DIR_IN) +#define EP5OUT ((5 << 1) | DIR_OUT) +#define EP5IN ((5 << 1) | DIR_IN) +#define EP6OUT ((6 << 1) | DIR_OUT) +#define EP6IN ((6 << 1) | DIR_IN) +#define EP7OUT ((7 << 1) | DIR_OUT) +#define EP7IN ((7 << 1) | DIR_IN) + +/* Maximum Packet sizes */ + +#define MAX_PACKET_SIZE_EP0 (64) +#define MAX_PACKET_SIZE_EP1 (64) +#define MAX_PACKET_SIZE_EP2 (64) +#define MAX_PACKET_SIZE_EP3 (64) +#define MAX_PACKET_SIZE_EP4 (64) +#define MAX_PACKET_SIZE_EP5 (64) +#define MAX_PACKET_SIZE_EP6 (64) +#define MAX_PACKET_SIZE_EP7 (64) + +/* Generic endpoints - intended to be portable accross devices */ +/* and be suitable for simple USB devices. */ + +/* Bulk endpoints */ +#define EPBULK_OUT (EP1OUT) +#define EPBULK_IN (EP2IN) +#define EPBULK_OUT_callback EP1_OUT_callback +#define EPBULK_IN_callback EP2_IN_callback +/* Interrupt endpoints */ +#define EPINT_OUT (EP3OUT) +#define EPINT_IN (EP4IN) +#define EPINT_OUT_callback EP3_OUT_callback +#define EPINT_IN_callback EP4_IN_callback + +#define MAX_PACKET_SIZE_EPBULK (64) +#define MAX_PACKET_SIZE_EPINT (64) diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h new file mode 100644 index 000000000..f25a3d862 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h @@ -0,0 +1,85 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#define NUMBER_OF_LOGICAL_ENDPOINTS (16) +#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2) + +/* Define physical endpoint numbers */ + +/* Endpoint No. Type(s) MaxSiz DoubleBuf pipe */ +/* ---------------- --------- ------ --------- ---- */ +#define EP0OUT (0) /* Control 256 No 0 */ +#define EP0IN (1) /* Control 256 No 0 */ +#define EP1OUT (2) /* Int 64 No 6 */ +#define EP1IN (3) /* Int 64 No 7 */ +#define EP2OUT (4) /* Bulk 2048 Yes 3 */ +#define EP2IN (5) /* Bulk 2048 Yes 4 */ +#define EP3OUT (6) /* Bulk/Iso 2048 Yes 1 */ +#define EP3IN (7) /* Bulk/Iso 2048 Yes 2 */ +/*following EP is not configured in sample program*/ +#define EP6IN (8) /* Bulk 2048 Yes 5 */ +#define EP8IN (9) /* Int 64 No 8 */ +#define EP9IN (10) /* Bulk 512 Bulk 9 */ +#define EP10IN (11) /* Int/Bulk 2048 Bulk 10 */ +#define EP11IN (12) /* Bulk 2048 Yes 11 */ +#define EP12IN (13) /* Bulk 2048 Yes 12 */ +#define EP13IN (14) /* Bulk 2048 Yes 13 */ +#define EP14IN (15) /* Bulk 2048 Yes 14 */ +#define EP15IN (16) /* Bulk 2048 Yes 15 */ + +/* Maximum Packet sizes */ +#define MAX_PACKET_SIZE_EP0 (64) /*pipe0/pipe0: control */ +#define MAX_PACKET_SIZE_EP1 (64) /*pipe6/pipe7: interrupt */ +#define MAX_PACKET_SIZE_EP2 (512) /*pipe3/pipe4: bulk */ +#define MAX_PACKET_SIZE_EP3 (512) /*pipe1/pipe2: isochronous */ +#define MAX_PACKET_SIZE_EP6 (64) /*pipe5: Note *1 */ +#define MAX_PACKET_SIZE_EP8 (64) /*pipe7: Note *1 */ +#define MAX_PACKET_SIZE_EP9 (512) /*pipe8: Note *1 */ +#define MAX_PACKET_SIZE_EP10 (512) /*pipe9: Note *1 */ +#define MAX_PACKET_SIZE_EP11 (512) /*pipe10: Note *1 */ +#define MAX_PACKET_SIZE_EP12 (512) /*pipe11: Note *1 */ +#define MAX_PACKET_SIZE_EP13 (512) /*pipe12: Note *1 */ +#define MAX_PACKET_SIZE_EP14 (512) /*pipe13: Note *1 */ +#define MAX_PACKET_SIZE_EP15 (512) /*pipe14: Note *1 */ +/* Note *1: This pipe is not configure in sample program */ + + +/* Generic endpoints - intended to be portable accross devices */ +/* and be suitable for simple USB devices. */ + +/* Bulk endpoints */ +#define EPBULK_OUT (EP2OUT) +#define EPBULK_IN (EP2IN) +#define EPBULK_OUT_callback EP2_OUT_callback +#define EPBULK_IN_callback EP2_IN_callback +/* Interrupt endpoints */ +#define EPINT_OUT (EP1OUT) +#define EPINT_IN (EP1IN) +#define EPINT_OUT_callback EP1_OUT_callback +#define EPINT_IN_callback EP1_IN_callback +/* Isochronous endpoints */ +#define EPISO_OUT (EP3OUT) +#define EPISO_IN (EP3IN) +#define EPISO_OUT_callback EP3_OUT_callback +#define EPISO_IN_callback EP3_IN_callback + +#define MAX_PACKET_SIZE_EPBULK (MAX_PACKET_SIZE_EP2) +#define MAX_PACKET_SIZE_EPINT (MAX_PACKET_SIZE_EP1) +#define MAX_PACKET_SIZE_EPISO (MAX_PACKET_SIZE_EP3) + +/*EOF*/ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_STM32F4.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_STM32F4.h new file mode 100644 index 000000000..1d520d11c --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_STM32F4.h @@ -0,0 +1,67 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#define NUMBER_OF_LOGICAL_ENDPOINTS (4) +#define NUMBER_OF_PHYSICAL_ENDPOINTS (NUMBER_OF_LOGICAL_ENDPOINTS * 2) + +/* Define physical endpoint numbers */ + +/* Endpoint No. Type(s) MaxPacket DoubleBuffer */ +/* ---------------- ------------ ---------- --- */ +#define EP0OUT (0) /* Control 64 No */ +#define EP0IN (1) /* Control 64 No */ +#define EP1OUT (2) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP1IN (3) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP2OUT (4) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP2IN (5) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP3OUT (6) /* Int/Bulk/Iso 64/64/1023 Yes */ +#define EP3IN (7) /* Int/Bulk/Iso 64/64/1023 Yes */ + +/* Maximum Packet sizes */ + +#define MAX_PACKET_SIZE_EP0 (64) +#define MAX_PACKET_SIZE_EP1 (64) /* Int/Bulk */ +#define MAX_PACKET_SIZE_EP2 (64) /* Int/Bulk */ +#define MAX_PACKET_SIZE_EP3 (64) /* Int/Bulk */ + +#define MAX_PACKET_SIZE_EP1_ISO (1023) /* Isochronous */ +#define MAX_PACKET_SIZE_EP2_ISO (1023) /* Isochronous */ +#define MAX_PACKET_SIZE_EP3_ISO (1023) /* Isochronous */ + +/* Generic endpoints - intended to be portable accross devices */ +/* and be suitable for simple USB devices. */ + +/* Bulk endpoint */ +#define EPBULK_OUT (EP2OUT) +#define EPBULK_IN (EP2IN) +#define EPBULK_OUT_callback EP2_OUT_callback +#define EPBULK_IN_callback EP2_IN_callback +/* Interrupt endpoint */ +#define EPINT_OUT (EP1OUT) +#define EPINT_IN (EP1IN) +#define EPINT_OUT_callback EP1_OUT_callback +#define EPINT_IN_callback EP1_IN_callback +/* Isochronous endpoint */ +#define EPISO_OUT (EP3OUT) +#define EPISO_IN (EP3IN) +#define EPISO_OUT_callback EP3_OUT_callback +#define EPISO_IN_callback EP3_IN_callback + +#define MAX_PACKET_SIZE_EPBULK (MAX_PACKET_SIZE_EP2) +#define MAX_PACKET_SIZE_EPINT (MAX_PACKET_SIZE_EP1) +#define MAX_PACKET_SIZE_EPISO (MAX_PACKET_SIZE_EP3_ISO) diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL.h new file mode 100644 index 000000000..faf22e8d5 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL.h @@ -0,0 +1,121 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBBUSINTERFACE_H +#define USBBUSINTERFACE_H + +#include "mbed.h" +#include "USBEndpoints.h" +#include "toolchain.h" + +//#ifdef __GNUC__ +//#define __packed __attribute__ ((__packed__)) +//#endif + +class USBHAL { +public: + /* Configuration */ + USBHAL(); + ~USBHAL(); + void connect(void); + void disconnect(void); + void configureDevice(void); + void unconfigureDevice(void); + void setAddress(uint8_t address); + void remoteWakeup(void); + + /* Endpoint 0 */ + void EP0setup(uint8_t *buffer); + void EP0read(void); + void EP0readStage(void); + uint32_t EP0getReadResult(uint8_t *buffer); + void EP0write(uint8_t *buffer, uint32_t size); + void EP0getWriteResult(void); + void EP0stall(void); + + /* Other endpoints */ + EP_STATUS endpointRead(uint8_t endpoint, uint32_t maximumSize); + EP_STATUS endpointReadResult(uint8_t endpoint, uint8_t *data, uint32_t *bytesRead); + EP_STATUS endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size); + EP_STATUS endpointWriteResult(uint8_t endpoint); + void stallEndpoint(uint8_t endpoint); + void unstallEndpoint(uint8_t endpoint); + bool realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t options); + bool getEndpointStallState(unsigned char endpoint); + uint32_t endpointReadcore(uint8_t endpoint, uint8_t *buffer); + +protected: + virtual void busReset(void){}; + virtual void EP0setupCallback(void){}; + virtual void EP0out(void){}; + virtual void EP0in(void){}; + virtual void connectStateChanged(unsigned int connected){}; + virtual void suspendStateChanged(unsigned int suspended){}; + virtual void SOF(int frameNumber){}; + + virtual bool EP1_OUT_callback(){return false;}; + virtual bool EP1_IN_callback(){return false;}; + virtual bool EP2_OUT_callback(){return false;}; + virtual bool EP2_IN_callback(){return false;}; + virtual bool EP3_OUT_callback(){return false;}; + virtual bool EP3_IN_callback(){return false;}; +#if !defined(TARGET_STM32F4) + virtual bool EP4_OUT_callback(){return false;}; + virtual bool EP4_IN_callback(){return false;}; +#if !(defined(TARGET_LPC11UXX) || defined(TARGET_LPC11U6X) || defined(TARGET_LPC1347) || defined(TARGET_LPC1549)) + virtual bool EP5_OUT_callback(){return false;}; + virtual bool EP5_IN_callback(){return false;}; + virtual bool EP6_OUT_callback(){return false;}; + virtual bool EP6_IN_callback(){return false;}; + virtual bool EP7_OUT_callback(){return false;}; + virtual bool EP7_IN_callback(){return false;}; + virtual bool EP8_OUT_callback(){return false;}; + virtual bool EP8_IN_callback(){return false;}; + virtual bool EP9_OUT_callback(){return false;}; + virtual bool EP9_IN_callback(){return false;}; + virtual bool EP10_OUT_callback(){return false;}; + virtual bool EP10_IN_callback(){return false;}; + virtual bool EP11_OUT_callback(){return false;}; + virtual bool EP11_IN_callback(){return false;}; + virtual bool EP12_OUT_callback(){return false;}; + virtual bool EP12_IN_callback(){return false;}; + virtual bool EP13_OUT_callback(){return false;}; + virtual bool EP13_IN_callback(){return false;}; + virtual bool EP14_OUT_callback(){return false;}; + virtual bool EP14_IN_callback(){return false;}; + virtual bool EP15_OUT_callback(){return false;}; + virtual bool EP15_IN_callback(){return false;}; +#endif +#endif + +private: + void usbisr(void); + static void _usbisr(void); + static USBHAL * instance; + +#if defined(TARGET_LPC11UXX) || defined(TARGET_LPC11U6X) || defined(TARGET_LPC1347) || defined(TARGET_LPC1549) + bool (USBHAL::*epCallback[10 - 2])(void); +#elif defined(TARGET_STM32F4) + bool (USBHAL::*epCallback[8 - 2])(void); +#else + bool (USBHAL::*epCallback[32 - 2])(void); +#endif + + +}; +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_KL25Z.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_KL25Z.cpp new file mode 100644 index 000000000..f92a99979 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_KL25Z.cpp @@ -0,0 +1,551 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#if defined(TARGET_KL25Z) | defined(TARGET_KL43Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D50M) | defined(TARGET_K64F) | defined(TARGET_K22F) | defined(TARGET_TEENSY3_1) + +#include "USBHAL.h" + +USBHAL * USBHAL::instance; + +static volatile int epComplete = 0; + +// Convert physical endpoint number to register bit +#define EP(endpoint) (1<<(endpoint)) + +// Convert physical to logical +#define PHY_TO_LOG(endpoint) ((endpoint)>>1) + +// Get endpoint direction +#define IN_EP(endpoint) ((endpoint) & 1U ? true : false) +#define OUT_EP(endpoint) ((endpoint) & 1U ? false : true) + +#define BD_OWN_MASK (1<<7) +#define BD_DATA01_MASK (1<<6) +#define BD_KEEP_MASK (1<<5) +#define BD_NINC_MASK (1<<4) +#define BD_DTS_MASK (1<<3) +#define BD_STALL_MASK (1<<2) + +#define TX 1 +#define RX 0 +#define ODD 0 +#define EVEN 1 +// this macro waits a physical endpoint number +#define EP_BDT_IDX(ep, dir, odd) (((ep * 4) + (2 * dir) + (1 * odd))) + +#define SETUP_TOKEN 0x0D +#define IN_TOKEN 0x09 +#define OUT_TOKEN 0x01 +#define TOK_PID(idx) ((bdt[idx].info >> 2) & 0x0F) + +// for each endpt: 8 bytes +typedef struct BDT { + uint8_t info; // BD[0:7] + uint8_t dummy; // RSVD: BD[8:15] + uint16_t byte_count; // BD[16:32] + uint32_t address; // Addr +} BDT; + + +// there are: +// * 16 bidirectionnal endpt -> 32 physical endpt +// * as there are ODD and EVEN buffer -> 32*2 bdt +__attribute__((__aligned__(512))) BDT bdt[NUMBER_OF_PHYSICAL_ENDPOINTS * 2]; +uint8_t * endpoint_buffer[(NUMBER_OF_PHYSICAL_ENDPOINTS - 2) * 2]; +uint8_t * endpoint_buffer_iso[2*2]; + +static uint8_t set_addr = 0; +static uint8_t addr = 0; + +static uint32_t Data1 = 0x55555555; + +static uint32_t frameNumber() { + return((USB0->FRMNUML | (USB0->FRMNUMH << 8)) & 0x07FF); +} + +uint32_t USBHAL::endpointReadcore(uint8_t endpoint, uint8_t *buffer) { + return 0; +} + +USBHAL::USBHAL(void) { + // Disable IRQ + NVIC_DisableIRQ(USB0_IRQn); + +#if defined(TARGET_K64F) + MPU->CESR=0; +#endif + // fill in callback array + epCallback[0] = &USBHAL::EP1_OUT_callback; + epCallback[1] = &USBHAL::EP1_IN_callback; + epCallback[2] = &USBHAL::EP2_OUT_callback; + epCallback[3] = &USBHAL::EP2_IN_callback; + epCallback[4] = &USBHAL::EP3_OUT_callback; + epCallback[5] = &USBHAL::EP3_IN_callback; + epCallback[6] = &USBHAL::EP4_OUT_callback; + epCallback[7] = &USBHAL::EP4_IN_callback; + epCallback[8] = &USBHAL::EP5_OUT_callback; + epCallback[9] = &USBHAL::EP5_IN_callback; + epCallback[10] = &USBHAL::EP6_OUT_callback; + epCallback[11] = &USBHAL::EP6_IN_callback; + epCallback[12] = &USBHAL::EP7_OUT_callback; + epCallback[13] = &USBHAL::EP7_IN_callback; + epCallback[14] = &USBHAL::EP8_OUT_callback; + epCallback[15] = &USBHAL::EP8_IN_callback; + epCallback[16] = &USBHAL::EP9_OUT_callback; + epCallback[17] = &USBHAL::EP9_IN_callback; + epCallback[18] = &USBHAL::EP10_OUT_callback; + epCallback[19] = &USBHAL::EP10_IN_callback; + epCallback[20] = &USBHAL::EP11_OUT_callback; + epCallback[21] = &USBHAL::EP11_IN_callback; + epCallback[22] = &USBHAL::EP12_OUT_callback; + epCallback[23] = &USBHAL::EP12_IN_callback; + epCallback[24] = &USBHAL::EP13_OUT_callback; + epCallback[25] = &USBHAL::EP13_IN_callback; + epCallback[26] = &USBHAL::EP14_OUT_callback; + epCallback[27] = &USBHAL::EP14_IN_callback; + epCallback[28] = &USBHAL::EP15_OUT_callback; + epCallback[29] = &USBHAL::EP15_IN_callback; + +#if defined(TARGET_KL43Z) + // enable USBFS clock + SIM->SCGC4 |= SIM_SCGC4_USBFS_MASK; + + // enable the IRC48M clock + USB0->CLK_RECOVER_IRC_EN |= USB_CLK_RECOVER_IRC_EN_IRC_EN_MASK; + + // enable the USB clock recovery tuning + USB0->CLK_RECOVER_CTRL |= USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN_MASK; + + // choose usb src clock + SIM->SOPT2 |= SIM_SOPT2_USBSRC_MASK; +#else + // choose usb src as PLL + SIM->SOPT2 &= ~SIM_SOPT2_PLLFLLSEL_MASK; + SIM->SOPT2 |= (SIM_SOPT2_USBSRC_MASK | (1 << SIM_SOPT2_PLLFLLSEL_SHIFT)); + + // enable OTG clock + SIM->SCGC4 |= SIM_SCGC4_USBOTG_MASK; +#endif + + // Attach IRQ + instance = this; + NVIC_SetVector(USB0_IRQn, (uint32_t)&_usbisr); + NVIC_EnableIRQ(USB0_IRQn); + + // USB Module Configuration + // Reset USB Module + USB0->USBTRC0 |= USB_USBTRC0_USBRESET_MASK; + while(USB0->USBTRC0 & USB_USBTRC0_USBRESET_MASK); + + // Set BDT Base Register + USB0->BDTPAGE1 = (uint8_t)((uint32_t)bdt>>8); + USB0->BDTPAGE2 = (uint8_t)((uint32_t)bdt>>16); + USB0->BDTPAGE3 = (uint8_t)((uint32_t)bdt>>24); + + // Clear interrupt flag + USB0->ISTAT = 0xff; + + // USB Interrupt Enablers + USB0->INTEN |= USB_INTEN_TOKDNEEN_MASK | + USB_INTEN_SOFTOKEN_MASK | + USB_INTEN_ERROREN_MASK | + USB_INTEN_USBRSTEN_MASK; + + // Disable weak pull downs + USB0->USBCTRL &= ~(USB_USBCTRL_PDE_MASK | USB_USBCTRL_SUSP_MASK); + + USB0->USBTRC0 |= 0x40; +} + +USBHAL::~USBHAL(void) { } + +void USBHAL::connect(void) { + // enable USB + USB0->CTL |= USB_CTL_USBENSOFEN_MASK; + // Pull up enable + USB0->CONTROL |= USB_CONTROL_DPPULLUPNONOTG_MASK; +} + +void USBHAL::disconnect(void) { + // disable USB + USB0->CTL &= ~USB_CTL_USBENSOFEN_MASK; + // Pull up disable + USB0->CONTROL &= ~USB_CONTROL_DPPULLUPNONOTG_MASK; + + //Free buffers if required: + for (int i = 0; i<(NUMBER_OF_PHYSICAL_ENDPOINTS - 2) * 2; i++) { + free(endpoint_buffer[i]); + endpoint_buffer[i] = NULL; + } + free(endpoint_buffer_iso[2]); + endpoint_buffer_iso[2] = NULL; + free(endpoint_buffer_iso[0]); + endpoint_buffer_iso[0] = NULL; +} + +void USBHAL::configureDevice(void) { + // not needed +} + +void USBHAL::unconfigureDevice(void) { + // not needed +} + +void USBHAL::setAddress(uint8_t address) { + // we don't set the address now otherwise the usb controller does not ack + // we set a flag instead + // see usbisr when an IN token is received + set_addr = 1; + addr = address; +} + +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags) { + uint32_t handshake_flag = 0; + uint8_t * buf; + + if (endpoint > NUMBER_OF_PHYSICAL_ENDPOINTS - 1) { + return false; + } + + uint32_t log_endpoint = PHY_TO_LOG(endpoint); + + if ((flags & ISOCHRONOUS) == 0) { + handshake_flag = USB_ENDPT_EPHSHK_MASK; + if (IN_EP(endpoint)) { + if (endpoint_buffer[EP_BDT_IDX(log_endpoint, TX, ODD)] == NULL) + endpoint_buffer[EP_BDT_IDX(log_endpoint, TX, ODD)] = (uint8_t *) malloc (64*2); + buf = &endpoint_buffer[EP_BDT_IDX(log_endpoint, TX, ODD)][0]; + } else { + if (endpoint_buffer[EP_BDT_IDX(log_endpoint, RX, ODD)] == NULL) + endpoint_buffer[EP_BDT_IDX(log_endpoint, RX, ODD)] = (uint8_t *) malloc (64*2); + buf = &endpoint_buffer[EP_BDT_IDX(log_endpoint, RX, ODD)][0]; + } + } else { + if (IN_EP(endpoint)) { + if (endpoint_buffer_iso[2] == NULL) + endpoint_buffer_iso[2] = (uint8_t *) malloc (1023*2); + buf = &endpoint_buffer_iso[2][0]; + } else { + if (endpoint_buffer_iso[0] == NULL) + endpoint_buffer_iso[0] = (uint8_t *) malloc (1023*2); + buf = &endpoint_buffer_iso[0][0]; + } + } + + // IN endpt -> device to host (TX) + if (IN_EP(endpoint)) { + USB0->ENDPOINT[log_endpoint].ENDPT |= handshake_flag | // ep handshaking (not if iso endpoint) + USB_ENDPT_EPTXEN_MASK; // en TX (IN) tran + bdt[EP_BDT_IDX(log_endpoint, TX, ODD )].address = (uint32_t) buf; + bdt[EP_BDT_IDX(log_endpoint, TX, EVEN)].address = 0; + } + // OUT endpt -> host to device (RX) + else { + USB0->ENDPOINT[log_endpoint].ENDPT |= handshake_flag | // ep handshaking (not if iso endpoint) + USB_ENDPT_EPRXEN_MASK; // en RX (OUT) tran. + bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].byte_count = maxPacket; + bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].address = (uint32_t) buf; + bdt[EP_BDT_IDX(log_endpoint, RX, ODD )].info = BD_OWN_MASK | BD_DTS_MASK; + bdt[EP_BDT_IDX(log_endpoint, RX, EVEN)].info = 0; + } + + Data1 |= (1 << endpoint); + + return true; +} + +// read setup packet +void USBHAL::EP0setup(uint8_t *buffer) { + uint32_t sz; + endpointReadResult(EP0OUT, buffer, &sz); +} + +void USBHAL::EP0readStage(void) { + Data1 &= ~1UL; // set DATA0 + bdt[0].info = (BD_DTS_MASK | BD_OWN_MASK); +} + +void USBHAL::EP0read(void) { + uint32_t idx = EP_BDT_IDX(PHY_TO_LOG(EP0OUT), RX, 0); + bdt[idx].byte_count = MAX_PACKET_SIZE_EP0; +} + +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) { + uint32_t sz; + endpointReadResult(EP0OUT, buffer, &sz); + return sz; +} + +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) { + endpointWrite(EP0IN, buffer, size); +} + +void USBHAL::EP0getWriteResult(void) { +} + +void USBHAL::EP0stall(void) { + stallEndpoint(EP0OUT); +} + +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize) { + endpoint = PHY_TO_LOG(endpoint); + uint32_t idx = EP_BDT_IDX(endpoint, RX, 0); + bdt[idx].byte_count = maximumSize; + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t * buffer, uint32_t *bytesRead) { + uint32_t n, sz, idx, setup = 0; + uint8_t not_iso; + uint8_t * ep_buf; + + uint32_t log_endpoint = PHY_TO_LOG(endpoint); + + if (endpoint > NUMBER_OF_PHYSICAL_ENDPOINTS - 1) { + return EP_INVALID; + } + + // if read on a IN endpoint -> error + if (IN_EP(endpoint)) { + return EP_INVALID; + } + + idx = EP_BDT_IDX(log_endpoint, RX, 0); + sz = bdt[idx].byte_count; + not_iso = USB0->ENDPOINT[log_endpoint].ENDPT & USB_ENDPT_EPHSHK_MASK; + + //for isochronous endpoint, we don't wait an interrupt + if ((log_endpoint != 0) && not_iso && !(epComplete & EP(endpoint))) { + return EP_PENDING; + } + + if ((log_endpoint == 0) && (TOK_PID(idx) == SETUP_TOKEN)) { + setup = 1; + } + + // non iso endpoint + if (not_iso) { + ep_buf = endpoint_buffer[idx]; + } else { + ep_buf = endpoint_buffer_iso[0]; + } + + for (n = 0; n < sz; n++) { + buffer[n] = ep_buf[n]; + } + + if (((Data1 >> endpoint) & 1) == ((bdt[idx].info >> 6) & 1)) { + if (setup && (buffer[6] == 0)) // if no setup data stage, + Data1 &= ~1UL; // set DATA0 + else + Data1 ^= (1 << endpoint); + } + + if (((Data1 >> endpoint) & 1)) { + bdt[idx].info = BD_DTS_MASK | BD_DATA01_MASK | BD_OWN_MASK; + } + else { + bdt[idx].info = BD_DTS_MASK | BD_OWN_MASK; + } + + USB0->CTL &= ~USB_CTL_TXSUSPENDTOKENBUSY_MASK; + *bytesRead = sz; + + epComplete &= ~EP(endpoint); + return EP_COMPLETED; +} + +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) { + uint32_t idx, n; + uint8_t * ep_buf; + + if (endpoint > NUMBER_OF_PHYSICAL_ENDPOINTS - 1) { + return EP_INVALID; + } + + // if write on a OUT endpoint -> error + if (OUT_EP(endpoint)) { + return EP_INVALID; + } + + idx = EP_BDT_IDX(PHY_TO_LOG(endpoint), TX, 0); + bdt[idx].byte_count = size; + + + // non iso endpoint + if (USB0->ENDPOINT[PHY_TO_LOG(endpoint)].ENDPT & USB_ENDPT_EPHSHK_MASK) { + ep_buf = endpoint_buffer[idx]; + } else { + ep_buf = endpoint_buffer_iso[2]; + } + + for (n = 0; n < size; n++) { + ep_buf[n] = data[n]; + } + + if ((Data1 >> endpoint) & 1) { + bdt[idx].info = BD_OWN_MASK | BD_DTS_MASK; + } else { + bdt[idx].info = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK; + } + + Data1 ^= (1 << endpoint); + + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) { + if (epComplete & EP(endpoint)) { + epComplete &= ~EP(endpoint); + return EP_COMPLETED; + } + + return EP_PENDING; +} + +void USBHAL::stallEndpoint(uint8_t endpoint) { + USB0->ENDPOINT[PHY_TO_LOG(endpoint)].ENDPT |= USB_ENDPT_EPSTALL_MASK; +} + +void USBHAL::unstallEndpoint(uint8_t endpoint) { + USB0->ENDPOINT[PHY_TO_LOG(endpoint)].ENDPT &= ~USB_ENDPT_EPSTALL_MASK; +} + +bool USBHAL::getEndpointStallState(uint8_t endpoint) { + uint8_t stall = (USB0->ENDPOINT[PHY_TO_LOG(endpoint)].ENDPT & USB_ENDPT_EPSTALL_MASK); + return (stall) ? true : false; +} + +void USBHAL::remoteWakeup(void) { + // [TODO] +} + + +void USBHAL::_usbisr(void) { + instance->usbisr(); +} + + +void USBHAL::usbisr(void) { + uint8_t i; + uint8_t istat = USB0->ISTAT; + + // reset interrupt + if (istat & USB_ISTAT_USBRST_MASK) { + // disable all endpt + for(i = 0; i < 16; i++) { + USB0->ENDPOINT[i].ENDPT = 0x00; + } + + // enable control endpoint + realiseEndpoint(EP0OUT, MAX_PACKET_SIZE_EP0, 0); + realiseEndpoint(EP0IN, MAX_PACKET_SIZE_EP0, 0); + + Data1 = 0x55555555; + USB0->CTL |= USB_CTL_ODDRST_MASK; + + USB0->ISTAT = 0xFF; // clear all interrupt status flags + USB0->ERRSTAT = 0xFF; // clear all error flags + USB0->ERREN = 0xFF; // enable error interrupt sources + USB0->ADDR = 0x00; // set default address + + return; + } + + // resume interrupt + if (istat & USB_ISTAT_RESUME_MASK) { + USB0->ISTAT = USB_ISTAT_RESUME_MASK; + } + + // SOF interrupt + if (istat & USB_ISTAT_SOFTOK_MASK) { + USB0->ISTAT = USB_ISTAT_SOFTOK_MASK; + // SOF event, read frame number + SOF(frameNumber()); + } + + // stall interrupt + if (istat & 1<<7) { + if (USB0->ENDPOINT[0].ENDPT & USB_ENDPT_EPSTALL_MASK) + USB0->ENDPOINT[0].ENDPT &= ~USB_ENDPT_EPSTALL_MASK; + USB0->ISTAT |= USB_ISTAT_STALL_MASK; + } + + // token interrupt + if (istat & 1<<3) { + uint32_t num = (USB0->STAT >> 4) & 0x0F; + uint32_t dir = (USB0->STAT >> 3) & 0x01; + uint32_t ev_odd = (USB0->STAT >> 2) & 0x01; + + // setup packet + if ((num == 0) && (TOK_PID((EP_BDT_IDX(num, dir, ev_odd))) == SETUP_TOKEN)) { + Data1 &= ~0x02; + bdt[EP_BDT_IDX(0, TX, EVEN)].info &= ~BD_OWN_MASK; + bdt[EP_BDT_IDX(0, TX, ODD)].info &= ~BD_OWN_MASK; + + // EP0 SETUP event (SETUP data received) + EP0setupCallback(); + + } else { + // OUT packet + if (TOK_PID((EP_BDT_IDX(num, dir, ev_odd))) == OUT_TOKEN) { + if (num == 0) + EP0out(); + else { + epComplete |= (1 << EP(num)); + if ((instance->*(epCallback[EP(num) - 2]))()) { + epComplete &= ~(1 << EP(num)); + } + } + } + + // IN packet + if (TOK_PID((EP_BDT_IDX(num, dir, ev_odd))) == IN_TOKEN) { + if (num == 0) { + EP0in(); + if (set_addr == 1) { + USB0->ADDR = addr & 0x7F; + set_addr = 0; + } + } + else { + epComplete |= (1 << (EP(num) + 1)); + if ((instance->*(epCallback[EP(num) + 1 - 2]))()) { + epComplete &= ~(1 << (EP(num) + 1)); + } + } + } + } + + USB0->ISTAT = USB_ISTAT_TOKDNE_MASK; + } + + // sleep interrupt + if (istat & 1<<4) { + USB0->ISTAT |= USB_ISTAT_SLEEP_MASK; + } + + // error interrupt + if (istat & USB_ISTAT_ERROR_MASK) { + USB0->ERRSTAT = 0xFF; + USB0->ISTAT |= USB_ISTAT_ERROR_MASK; + } +} + + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC11U.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC11U.cpp new file mode 100644 index 000000000..1a5fa8c0f --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC11U.cpp @@ -0,0 +1,738 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#if defined(TARGET_LPC11UXX) || defined(TARGET_LPC11U6X) || defined(TARGET_LPC1347) || defined(TARGET_LPC1549) + +#if defined(TARGET_LPC1347) || defined(TARGET_LPC1549) +#define USB_IRQ USB_IRQ_IRQn +#else +#define USB_IRQ USB_IRQn +#endif + +#include "USBHAL.h" + +USBHAL * USBHAL::instance; +#if defined(TARGET_LPC1549) +static uint8_t usbmem[2048] __attribute__((aligned(2048))); +#endif + +// Valid physical endpoint numbers are 0 to (NUMBER_OF_PHYSICAL_ENDPOINTS-1) +#define LAST_PHYSICAL_ENDPOINT (NUMBER_OF_PHYSICAL_ENDPOINTS-1) + +// Convert physical endpoint number to register bit +#define EP(endpoint) (1UL<<endpoint) + +// Convert physical to logical +#define PHY_TO_LOG(endpoint) ((endpoint)>>1) + +// Get endpoint direction +#define IN_EP(endpoint) ((endpoint) & 1U ? true : false) +#define OUT_EP(endpoint) ((endpoint) & 1U ? false : true) + +// USB RAM +#if defined(TARGET_LPC1549) +#define USB_RAM_START ((uint32_t)usbmem) +#define USB_RAM_SIZE sizeof(usbmem) +#else +#define USB_RAM_START (0x20004000) +#define USB_RAM_SIZE (0x00000800) +#endif + +// SYSAHBCLKCTRL +#if defined(TARGET_LPC1549) +#define CLK_USB (1UL<<23) +#else +#define CLK_USB (1UL<<14) +#define CLK_USBRAM (1UL<<27) +#endif + +// USB Information register +#define FRAME_NR(a) ((a) & 0x7ff) // Frame number + +// USB Device Command/Status register +#define DEV_ADDR_MASK (0x7f) // Device address +#define DEV_ADDR(a) ((a) & DEV_ADDR_MASK) +#define DEV_EN (1UL<<7) // Device enable +#define SETUP (1UL<<8) // SETUP token received +#define PLL_ON (1UL<<9) // PLL enabled in suspend +#define DCON (1UL<<16) // Device status - connect +#define DSUS (1UL<<17) // Device status - suspend +#define DCON_C (1UL<<24) // Connect change +#define DSUS_C (1UL<<25) // Suspend change +#define DRES_C (1UL<<26) // Reset change +#define VBUSDEBOUNCED (1UL<<28) // Vbus detected + +// Endpoint Command/Status list +#define CMDSTS_A (1UL<<31) // Active +#define CMDSTS_D (1UL<<30) // Disable +#define CMDSTS_S (1UL<<29) // Stall +#define CMDSTS_TR (1UL<<28) // Toggle Reset +#define CMDSTS_RF (1UL<<27) // Rate Feedback mode +#define CMDSTS_TV (1UL<<27) // Toggle Value +#define CMDSTS_T (1UL<<26) // Endpoint Type +#define CMDSTS_NBYTES(n) (((n)&0x3ff)<<16) // Number of bytes +#define CMDSTS_ADDRESS_OFFSET(a) (((a)>>6)&0xffff) // Buffer start address + +#define BYTES_REMAINING(s) (((s)>>16)&0x3ff) // Bytes remaining after transfer + +// USB Non-endpoint interrupt sources +#define FRAME_INT (1UL<<30) +#define DEV_INT (1UL<<31) + +static volatile int epComplete = 0; + +// One entry for a double-buffered logical endpoint in the endpoint +// command/status list. Endpoint 0 is single buffered, out[1] is used +// for the SETUP packet and in[1] is not used +typedef struct { + uint32_t out[2]; + uint32_t in[2]; +} PACKED EP_COMMAND_STATUS; + +typedef struct { + uint8_t out[MAX_PACKET_SIZE_EP0]; + uint8_t in[MAX_PACKET_SIZE_EP0]; + uint8_t setup[SETUP_PACKET_SIZE]; +} PACKED CONTROL_TRANSFER; + +typedef struct { + uint32_t maxPacket; + uint32_t buffer[2]; + uint32_t options; +} PACKED EP_STATE; + +static volatile EP_STATE endpointState[NUMBER_OF_PHYSICAL_ENDPOINTS]; + +// Pointer to the endpoint command/status list +static EP_COMMAND_STATUS *ep = NULL; + +// Pointer to endpoint 0 data (IN/OUT and SETUP) +static CONTROL_TRANSFER *ct = NULL; + +// Shadow DEVCMDSTAT register to avoid accidentally clearing flags or +// initiating a remote wakeup event. +static volatile uint32_t devCmdStat; + +// Pointers used to allocate USB RAM +static uint32_t usbRamPtr = USB_RAM_START; +static uint32_t epRamPtr = 0; // Buffers for endpoints > 0 start here + +#define ROUND_UP_TO_MULTIPLE(x, m) ((((x)+((m)-1))/(m))*(m)) + +void USBMemCopy(uint8_t *dst, uint8_t *src, uint32_t size); +void USBMemCopy(uint8_t *dst, uint8_t *src, uint32_t size) { + if (size > 0) { + do { + *dst++ = *src++; + } while (--size > 0); + } +} + + +USBHAL::USBHAL(void) { + NVIC_DisableIRQ(USB_IRQ); + + // fill in callback array + epCallback[0] = &USBHAL::EP1_OUT_callback; + epCallback[1] = &USBHAL::EP1_IN_callback; + epCallback[2] = &USBHAL::EP2_OUT_callback; + epCallback[3] = &USBHAL::EP2_IN_callback; + epCallback[4] = &USBHAL::EP3_OUT_callback; + epCallback[5] = &USBHAL::EP3_IN_callback; + epCallback[6] = &USBHAL::EP4_OUT_callback; + epCallback[7] = &USBHAL::EP4_IN_callback; + +#if defined(TARGET_LPC1549) + /* Set USB PLL input to system oscillator */ + LPC_SYSCON->USBPLLCLKSEL = 0x01; + + /* Setup USB PLL (FCLKIN = 12MHz) * 4 = 48MHz + MSEL = 3 (this is pre-decremented), PSEL = 1 (for P = 2) + FCLKOUT = FCLKIN * (MSEL + 1) = 12MHz * 4 = 48MHz + FCCO = FCLKOUT * 2 * P = 48MHz * 2 * 2 = 192MHz (within FCCO range) */ + LPC_SYSCON->USBPLLCTRL = (0x3 | (1UL << 6)); + + /* Powerup USB PLL */ + LPC_SYSCON->PDRUNCFG &= ~(CLK_USB); + + /* Wait for PLL to lock */ + while(!(LPC_SYSCON->USBPLLSTAT & 0x01)); + + /* enable USB main clock */ + LPC_SYSCON->USBCLKSEL = 0x02; + LPC_SYSCON->USBCLKDIV = 1; + + /* Enable AHB clock to the USB block. */ + LPC_SYSCON->SYSAHBCLKCTRL1 |= CLK_USB; + + /* power UP USB Phy */ + LPC_SYSCON->PDRUNCFG &= ~(1UL << 9); + + /* Reset USB block */ + LPC_SYSCON->PRESETCTRL1 |= (CLK_USB); + LPC_SYSCON->PRESETCTRL1 &= ~(CLK_USB); + +#else + #if defined(TARGET_LPC11U35_401) || defined(TARGET_LPC11U35_501) + // USB_VBUS input with pull-down + LPC_IOCON->PIO0_3 = 0x00000009; + #endif + + // nUSB_CONNECT output + LPC_IOCON->PIO0_6 = 0x00000001; + + // Enable clocks (USB registers, USB RAM) + LPC_SYSCON->SYSAHBCLKCTRL |= CLK_USB | CLK_USBRAM; + + // Ensure device disconnected (DCON not set) + LPC_USB->DEVCMDSTAT = 0; +#endif + // to ensure that the USB host sees the device as + // disconnected if the target CPU is reset. + wait(0.3); + + // Reserve space in USB RAM for endpoint command/status list + // Must be 256 byte aligned + usbRamPtr = ROUND_UP_TO_MULTIPLE(usbRamPtr, 256); + ep = (EP_COMMAND_STATUS *)usbRamPtr; + usbRamPtr += (sizeof(EP_COMMAND_STATUS) * NUMBER_OF_LOGICAL_ENDPOINTS); + LPC_USB->EPLISTSTART = (uint32_t)(ep) & 0xffffff00; + + // Reserve space in USB RAM for Endpoint 0 + // Must be 64 byte aligned + usbRamPtr = ROUND_UP_TO_MULTIPLE(usbRamPtr, 64); + ct = (CONTROL_TRANSFER *)usbRamPtr; + usbRamPtr += sizeof(CONTROL_TRANSFER); + LPC_USB->DATABUFSTART =(uint32_t)(ct) & 0xffc00000; + + // Setup command/status list for EP0 + ep[0].out[0] = 0; + ep[0].in[0] = 0; + ep[0].out[1] = CMDSTS_ADDRESS_OFFSET((uint32_t)ct->setup); + + // Route all interrupts to IRQ, some can be routed to + // USB_FIQ if you wish. + LPC_USB->INTROUTING = 0; + + // Set device address 0, enable USB device, no remote wakeup + devCmdStat = DEV_ADDR(0) | DEV_EN | DSUS; + LPC_USB->DEVCMDSTAT = devCmdStat; + + // Enable interrupts for device events and EP0 + LPC_USB->INTEN = DEV_INT | EP(EP0IN) | EP(EP0OUT) | FRAME_INT; + instance = this; + + //attach IRQ handler and enable interrupts + NVIC_SetVector(USB_IRQ, (uint32_t)&_usbisr); +} + +USBHAL::~USBHAL(void) { + // Ensure device disconnected (DCON not set) + LPC_USB->DEVCMDSTAT = 0; + // Disable USB interrupts + NVIC_DisableIRQ(USB_IRQ); +} + +void USBHAL::connect(void) { + NVIC_EnableIRQ(USB_IRQ); + devCmdStat |= DCON; + LPC_USB->DEVCMDSTAT = devCmdStat; +} + +void USBHAL::disconnect(void) { + NVIC_DisableIRQ(USB_IRQ); + devCmdStat &= ~DCON; + LPC_USB->DEVCMDSTAT = devCmdStat; +} + +void USBHAL::configureDevice(void) { + // Not required +} + +void USBHAL::unconfigureDevice(void) { + // Not required +} + +void USBHAL::EP0setup(uint8_t *buffer) { + // Copy setup packet data + USBMemCopy(buffer, ct->setup, SETUP_PACKET_SIZE); +} + +void USBHAL::EP0read(void) { + // Start an endpoint 0 read + + // The USB ISR will call USBDevice_EP0out() when a packet has been read, + // the USBDevice layer then calls USBBusInterface_EP0getReadResult() to + // read the data. + + ep[0].out[0] = CMDSTS_A |CMDSTS_NBYTES(MAX_PACKET_SIZE_EP0) \ + | CMDSTS_ADDRESS_OFFSET((uint32_t)ct->out); +} + +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) { + // Complete an endpoint 0 read + uint32_t bytesRead; + + // Find how many bytes were read + bytesRead = MAX_PACKET_SIZE_EP0 - BYTES_REMAINING(ep[0].out[0]); + + // Copy data + USBMemCopy(buffer, ct->out, bytesRead); + return bytesRead; +} + + +void USBHAL::EP0readStage(void) { + // Not required +} + +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) { + // Start and endpoint 0 write + + // The USB ISR will call USBDevice_EP0in() when the data has + // been written, the USBDevice layer then calls + // USBBusInterface_EP0getWriteResult() to complete the transaction. + + // Copy data + USBMemCopy(ct->in, buffer, size); + + // Start transfer + ep[0].in[0] = CMDSTS_A | CMDSTS_NBYTES(size) \ + | CMDSTS_ADDRESS_OFFSET((uint32_t)ct->in); +} + + +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize) { + uint8_t bf = 0; + uint32_t flags = 0; + + //check which buffer must be filled + if (LPC_USB->EPBUFCFG & EP(endpoint)) { + // Double buffered + if (LPC_USB->EPINUSE & EP(endpoint)) { + bf = 1; + } else { + bf = 0; + } + } + + // if isochronous endpoint, T = 1 + if(endpointState[endpoint].options & ISOCHRONOUS) + { + flags |= CMDSTS_T; + } + + //Active the endpoint for reading + ep[PHY_TO_LOG(endpoint)].out[bf] = CMDSTS_A | CMDSTS_NBYTES(maximumSize) \ + | CMDSTS_ADDRESS_OFFSET((uint32_t)ct->out) | flags; + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t *data, uint32_t *bytesRead) { + + uint8_t bf = 0; + + if (!(epComplete & EP(endpoint))) + return EP_PENDING; + else { + epComplete &= ~EP(endpoint); + + //check which buffer has been filled + if (LPC_USB->EPBUFCFG & EP(endpoint)) { + // Double buffered (here we read the previous buffer which was used) + if (LPC_USB->EPINUSE & EP(endpoint)) { + bf = 0; + } else { + bf = 1; + } + } + + // Find how many bytes were read + *bytesRead = (uint32_t) (endpointState[endpoint].maxPacket - BYTES_REMAINING(ep[PHY_TO_LOG(endpoint)].out[bf])); + + // Copy data + USBMemCopy(data, ct->out, *bytesRead); + return EP_COMPLETED; + } +} + +void USBHAL::EP0getWriteResult(void) { + // Not required +} + +void USBHAL::EP0stall(void) { + ep[0].in[0] = CMDSTS_S; + ep[0].out[0] = CMDSTS_S; +} + +void USBHAL::setAddress(uint8_t address) { + devCmdStat &= ~DEV_ADDR_MASK; + devCmdStat |= DEV_ADDR(address); + LPC_USB->DEVCMDSTAT = devCmdStat; +} + +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) { + uint32_t flags = 0; + uint32_t bf; + + // Validate parameters + if (data == NULL) { + return EP_INVALID; + } + + if (endpoint > LAST_PHYSICAL_ENDPOINT) { + return EP_INVALID; + } + + if ((endpoint==EP0IN) || (endpoint==EP0OUT)) { + return EP_INVALID; + } + + if (size > endpointState[endpoint].maxPacket) { + return EP_INVALID; + } + + if (LPC_USB->EPBUFCFG & EP(endpoint)) { + // Double buffered + if (LPC_USB->EPINUSE & EP(endpoint)) { + bf = 1; + } else { + bf = 0; + } + } else { + // Single buffered + bf = 0; + } + + // Check if already active + if (ep[PHY_TO_LOG(endpoint)].in[bf] & CMDSTS_A) { + return EP_INVALID; + } + + // Check if stalled + if (ep[PHY_TO_LOG(endpoint)].in[bf] & CMDSTS_S) { + return EP_STALLED; + } + + // Copy data to USB RAM + USBMemCopy((uint8_t *)endpointState[endpoint].buffer[bf], data, size); + + // Add options + if (endpointState[endpoint].options & RATE_FEEDBACK_MODE) { + flags |= CMDSTS_RF; + } + + if (endpointState[endpoint].options & ISOCHRONOUS) { + flags |= CMDSTS_T; + } + + // Add transfer + ep[PHY_TO_LOG(endpoint)].in[bf] = CMDSTS_ADDRESS_OFFSET( \ + endpointState[endpoint].buffer[bf]) \ + | CMDSTS_NBYTES(size) | CMDSTS_A | flags; + + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) { + uint32_t bf; + + // Validate parameters + if (endpoint > LAST_PHYSICAL_ENDPOINT) { + return EP_INVALID; + } + + if (OUT_EP(endpoint)) { + return EP_INVALID; + } + + if (LPC_USB->EPBUFCFG & EP(endpoint)) { + // Double buffered // TODO: FIX THIS + if (LPC_USB->EPINUSE & EP(endpoint)) { + bf = 1; + } else { + bf = 0; + } + } else { + // Single buffered + bf = 0; + } + + // Check if endpoint still active + if (ep[PHY_TO_LOG(endpoint)].in[bf] & CMDSTS_A) { + return EP_PENDING; + } + + // Check if stalled + if (ep[PHY_TO_LOG(endpoint)].in[bf] & CMDSTS_S) { + return EP_STALLED; + } + + return EP_COMPLETED; +} + +void USBHAL::stallEndpoint(uint8_t endpoint) { + + // FIX: should this clear active bit? + if (IN_EP(endpoint)) { + ep[PHY_TO_LOG(endpoint)].in[0] |= CMDSTS_S; + ep[PHY_TO_LOG(endpoint)].in[1] |= CMDSTS_S; + } else { + ep[PHY_TO_LOG(endpoint)].out[0] |= CMDSTS_S; + ep[PHY_TO_LOG(endpoint)].out[1] |= CMDSTS_S; + } +} + +void USBHAL::unstallEndpoint(uint8_t endpoint) { + if (LPC_USB->EPBUFCFG & EP(endpoint)) { + // Double buffered + if (IN_EP(endpoint)) { + ep[PHY_TO_LOG(endpoint)].in[0] = 0; // S = 0 + ep[PHY_TO_LOG(endpoint)].in[1] = 0; // S = 0 + + if (LPC_USB->EPINUSE & EP(endpoint)) { + ep[PHY_TO_LOG(endpoint)].in[1] = CMDSTS_TR; // S = 0, TR = 1, TV = 0 + } else { + ep[PHY_TO_LOG(endpoint)].in[0] = CMDSTS_TR; // S = 0, TR = 1, TV = 0 + } + } else { + ep[PHY_TO_LOG(endpoint)].out[0] = 0; // S = 0 + ep[PHY_TO_LOG(endpoint)].out[1] = 0; // S = 0 + + if (LPC_USB->EPINUSE & EP(endpoint)) { + ep[PHY_TO_LOG(endpoint)].out[1] = CMDSTS_TR; // S = 0, TR = 1, TV = 0 + } else { + ep[PHY_TO_LOG(endpoint)].out[0] = CMDSTS_TR; // S = 0, TR = 1, TV = 0 + } + } + } else { + // Single buffered + if (IN_EP(endpoint)) { + ep[PHY_TO_LOG(endpoint)].in[0] = CMDSTS_TR; // S = 0, TR = 1, TV = 0 + } else { + ep[PHY_TO_LOG(endpoint)].out[0] = CMDSTS_TR; // S = 0, TR = 1, TV = 0 + } + } +} + +bool USBHAL::getEndpointStallState(unsigned char endpoint) { + if (IN_EP(endpoint)) { + if (LPC_USB->EPINUSE & EP(endpoint)) { + if (ep[PHY_TO_LOG(endpoint)].in[1] & CMDSTS_S) { + return true; + } + } else { + if (ep[PHY_TO_LOG(endpoint)].in[0] & CMDSTS_S) { + return true; + } + } + } else { + if (LPC_USB->EPINUSE & EP(endpoint)) { + if (ep[PHY_TO_LOG(endpoint)].out[1] & CMDSTS_S) { + return true; + } + } else { + if (ep[PHY_TO_LOG(endpoint)].out[0] & CMDSTS_S) { + return true; + } + } + } + + return false; +} + +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t options) { + uint32_t tmpEpRamPtr; + + if (endpoint > LAST_PHYSICAL_ENDPOINT) { + return false; + } + + // Not applicable to the control endpoints + if ((endpoint==EP0IN) || (endpoint==EP0OUT)) { + return false; + } + + // Allocate buffers in USB RAM + tmpEpRamPtr = epRamPtr; + + // Must be 64 byte aligned + tmpEpRamPtr = ROUND_UP_TO_MULTIPLE(tmpEpRamPtr, 64); + + if ((tmpEpRamPtr + maxPacket) > (USB_RAM_START + USB_RAM_SIZE)) { + // Out of memory + return false; + } + + // Allocate first buffer + endpointState[endpoint].buffer[0] = tmpEpRamPtr; + tmpEpRamPtr += maxPacket; + + if (!(options & SINGLE_BUFFERED)) { + // Must be 64 byte aligned + tmpEpRamPtr = ROUND_UP_TO_MULTIPLE(tmpEpRamPtr, 64); + + if ((tmpEpRamPtr + maxPacket) > (USB_RAM_START + USB_RAM_SIZE)) { + // Out of memory + return false; + } + + // Allocate second buffer + endpointState[endpoint].buffer[1] = tmpEpRamPtr; + tmpEpRamPtr += maxPacket; + } + + // Commit to this USB RAM allocation + epRamPtr = tmpEpRamPtr; + + // Remaining endpoint state values + endpointState[endpoint].maxPacket = maxPacket; + endpointState[endpoint].options = options; + + // Enable double buffering if required + if (options & SINGLE_BUFFERED) { + LPC_USB->EPBUFCFG &= ~EP(endpoint); + } else { + // Double buffered + LPC_USB->EPBUFCFG |= EP(endpoint); + } + + // Enable interrupt + LPC_USB->INTEN |= EP(endpoint); + + // Enable endpoint + unstallEndpoint(endpoint); + return true; +} + +void USBHAL::remoteWakeup(void) { + // Clearing DSUS bit initiates a remote wakeup if the + // device is currently enabled and suspended - otherwise + // it has no effect. + LPC_USB->DEVCMDSTAT = devCmdStat & ~DSUS; +} + + +static void disableEndpoints(void) { + uint32_t logEp; + + // Ref. Table 158 "When a bus reset is received, software + // must set the disable bit of all endpoints to 1". + + for (logEp = 1; logEp < NUMBER_OF_LOGICAL_ENDPOINTS; logEp++) { + ep[logEp].out[0] = CMDSTS_D; + ep[logEp].out[1] = CMDSTS_D; + ep[logEp].in[0] = CMDSTS_D; + ep[logEp].in[1] = CMDSTS_D; + } + + // Start of USB RAM for endpoints > 0 + epRamPtr = usbRamPtr; +} + + + +void USBHAL::_usbisr(void) { + instance->usbisr(); +} + +void USBHAL::usbisr(void) { + // Start of frame + if (LPC_USB->INTSTAT & FRAME_INT) { + // Clear SOF interrupt + LPC_USB->INTSTAT = FRAME_INT; + + // SOF event, read frame number + SOF(FRAME_NR(LPC_USB->INFO)); + } + + // Device state + if (LPC_USB->INTSTAT & DEV_INT) { + LPC_USB->INTSTAT = DEV_INT; + + if (LPC_USB->DEVCMDSTAT & DSUS_C) { + // Suspend status changed + LPC_USB->DEVCMDSTAT = devCmdStat | DSUS_C; + if((LPC_USB->DEVCMDSTAT & DSUS) != 0) { + suspendStateChanged(1); + } + } + + if (LPC_USB->DEVCMDSTAT & DRES_C) { + // Bus reset + LPC_USB->DEVCMDSTAT = devCmdStat | DRES_C; + + suspendStateChanged(0); + + // Disable endpoints > 0 + disableEndpoints(); + + // Bus reset event + busReset(); + } + } + + // Endpoint 0 + if (LPC_USB->INTSTAT & EP(EP0OUT)) { + // Clear EP0OUT/SETUP interrupt + LPC_USB->INTSTAT = EP(EP0OUT); + + // Check if SETUP + if (LPC_USB->DEVCMDSTAT & SETUP) { + // Clear Active and Stall bits for EP0 + // Documentation does not make it clear if we must use the + // EPSKIP register to achieve this, Fig. 16 and NXP reference + // code suggests we can just clear the Active bits - check with + // NXP to be sure. + ep[0].in[0] = 0; + ep[0].out[0] = 0; + + // Clear EP0IN interrupt + LPC_USB->INTSTAT = EP(EP0IN); + + // Clear SETUP (and INTONNAK_CI/O) in device status register + LPC_USB->DEVCMDSTAT = devCmdStat | SETUP; + + // EP0 SETUP event (SETUP data received) + EP0setupCallback(); + } else { + // EP0OUT ACK event (OUT data received) + EP0out(); + } + } + + if (LPC_USB->INTSTAT & EP(EP0IN)) { + // Clear EP0IN interrupt + LPC_USB->INTSTAT = EP(EP0IN); + + // EP0IN ACK event (IN data sent) + EP0in(); + } + + for (uint8_t num = 2; num < 5*2; num++) { + if (LPC_USB->INTSTAT & EP(num)) { + LPC_USB->INTSTAT = EP(num); + epComplete |= EP(num); + if ((instance->*(epCallback[num - 2]))()) { + epComplete &= ~EP(num); + } + } + } +} + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC17.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC17.cpp new file mode 100644 index 000000000..8bffe10ac --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC17.cpp @@ -0,0 +1,623 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#if defined(TARGET_LPC1768) || defined(TARGET_LPC2368) + +#include "USBHAL.h" + + +// Get endpoint direction +#define IN_EP(endpoint) ((endpoint) & 1U ? true : false) +#define OUT_EP(endpoint) ((endpoint) & 1U ? false : true) + +// Convert physical endpoint number to register bit +#define EP(endpoint) (1UL<<endpoint) + +// Power Control for Peripherals register +#define PCUSB (1UL<<31) + +// USB Clock Control register +#define DEV_CLK_EN (1UL<<1) +#define AHB_CLK_EN (1UL<<4) + +// USB Clock Status register +#define DEV_CLK_ON (1UL<<1) +#define AHB_CLK_ON (1UL<<4) + +// USB Device Interupt registers +#define FRAME (1UL<<0) +#define EP_FAST (1UL<<1) +#define EP_SLOW (1UL<<2) +#define DEV_STAT (1UL<<3) +#define CCEMPTY (1UL<<4) +#define CDFULL (1UL<<5) +#define RxENDPKT (1UL<<6) +#define TxENDPKT (1UL<<7) +#define EP_RLZED (1UL<<8) +#define ERR_INT (1UL<<9) + +// USB Control register +#define RD_EN (1<<0) +#define WR_EN (1<<1) +#define LOG_ENDPOINT(endpoint) ((endpoint>>1)<<2) + +// USB Receive Packet Length register +#define DV (1UL<<10) +#define PKT_RDY (1UL<<11) +#define PKT_LNGTH_MASK (0x3ff) + +// Serial Interface Engine (SIE) +#define SIE_WRITE (0x01) +#define SIE_READ (0x02) +#define SIE_COMMAND (0x05) +#define SIE_CMD_CODE(phase, data) ((phase<<8)|(data<<16)) + +// SIE Command codes +#define SIE_CMD_SET_ADDRESS (0xD0) +#define SIE_CMD_CONFIGURE_DEVICE (0xD8) +#define SIE_CMD_SET_MODE (0xF3) +#define SIE_CMD_READ_FRAME_NUMBER (0xF5) +#define SIE_CMD_READ_TEST_REGISTER (0xFD) +#define SIE_CMD_SET_DEVICE_STATUS (0xFE) +#define SIE_CMD_GET_DEVICE_STATUS (0xFE) +#define SIE_CMD_GET_ERROR_CODE (0xFF) +#define SIE_CMD_READ_ERROR_STATUS (0xFB) + +#define SIE_CMD_SELECT_ENDPOINT(endpoint) (0x00+endpoint) +#define SIE_CMD_SELECT_ENDPOINT_CLEAR_INTERRUPT(endpoint) (0x40+endpoint) +#define SIE_CMD_SET_ENDPOINT_STATUS(endpoint) (0x40+endpoint) + +#define SIE_CMD_CLEAR_BUFFER (0xF2) +#define SIE_CMD_VALIDATE_BUFFER (0xFA) + +// SIE Device Status register +#define SIE_DS_CON (1<<0) +#define SIE_DS_CON_CH (1<<1) +#define SIE_DS_SUS (1<<2) +#define SIE_DS_SUS_CH (1<<3) +#define SIE_DS_RST (1<<4) + +// SIE Device Set Address register +#define SIE_DSA_DEV_EN (1<<7) + +// SIE Configue Device register +#define SIE_CONF_DEVICE (1<<0) + +// Select Endpoint register +#define SIE_SE_FE (1<<0) +#define SIE_SE_ST (1<<1) +#define SIE_SE_STP (1<<2) +#define SIE_SE_PO (1<<3) +#define SIE_SE_EPN (1<<4) +#define SIE_SE_B_1_FULL (1<<5) +#define SIE_SE_B_2_FULL (1<<6) + +// Set Endpoint Status command +#define SIE_SES_ST (1<<0) +#define SIE_SES_DA (1<<5) +#define SIE_SES_RF_MO (1<<6) +#define SIE_SES_CND_ST (1<<7) + + +USBHAL * USBHAL::instance; + +static volatile int epComplete; +static uint32_t endpointStallState; + +static void SIECommand(uint32_t command) { + // The command phase of a SIE transaction + LPC_USB->USBDevIntClr = CCEMPTY; + LPC_USB->USBCmdCode = SIE_CMD_CODE(SIE_COMMAND, command); + while (!(LPC_USB->USBDevIntSt & CCEMPTY)); +} + +static void SIEWriteData(uint8_t data) { + // The data write phase of a SIE transaction + LPC_USB->USBDevIntClr = CCEMPTY; + LPC_USB->USBCmdCode = SIE_CMD_CODE(SIE_WRITE, data); + while (!(LPC_USB->USBDevIntSt & CCEMPTY)); +} + +static uint8_t SIEReadData(uint32_t command) { + // The data read phase of a SIE transaction + LPC_USB->USBDevIntClr = CDFULL; + LPC_USB->USBCmdCode = SIE_CMD_CODE(SIE_READ, command); + while (!(LPC_USB->USBDevIntSt & CDFULL)); + return (uint8_t)LPC_USB->USBCmdData; +} + +static void SIEsetDeviceStatus(uint8_t status) { + // Write SIE device status register + SIECommand(SIE_CMD_SET_DEVICE_STATUS); + SIEWriteData(status); +} + +static uint8_t SIEgetDeviceStatus(void) { + // Read SIE device status register + SIECommand(SIE_CMD_GET_DEVICE_STATUS); + return SIEReadData(SIE_CMD_GET_DEVICE_STATUS); +} + +void SIEsetAddress(uint8_t address) { + // Write SIE device address register + SIECommand(SIE_CMD_SET_ADDRESS); + SIEWriteData((address & 0x7f) | SIE_DSA_DEV_EN); +} + +static uint8_t SIEselectEndpoint(uint8_t endpoint) { + // SIE select endpoint command + SIECommand(SIE_CMD_SELECT_ENDPOINT(endpoint)); + return SIEReadData(SIE_CMD_SELECT_ENDPOINT(endpoint)); +} + +static uint8_t SIEclearBuffer(void) { + // SIE clear buffer command + SIECommand(SIE_CMD_CLEAR_BUFFER); + return SIEReadData(SIE_CMD_CLEAR_BUFFER); +} + +static void SIEvalidateBuffer(void) { + // SIE validate buffer command + SIECommand(SIE_CMD_VALIDATE_BUFFER); +} + +static void SIEsetEndpointStatus(uint8_t endpoint, uint8_t status) { + // SIE set endpoint status command + SIECommand(SIE_CMD_SET_ENDPOINT_STATUS(endpoint)); + SIEWriteData(status); +} + +static uint16_t SIEgetFrameNumber(void) __attribute__ ((unused)); +static uint16_t SIEgetFrameNumber(void) { + // Read current frame number + uint16_t lowByte; + uint16_t highByte; + + SIECommand(SIE_CMD_READ_FRAME_NUMBER); + lowByte = SIEReadData(SIE_CMD_READ_FRAME_NUMBER); + highByte = SIEReadData(SIE_CMD_READ_FRAME_NUMBER); + + return (highByte << 8) | lowByte; +} + +static void SIEconfigureDevice(void) { + // SIE Configure device command + SIECommand(SIE_CMD_CONFIGURE_DEVICE); + SIEWriteData(SIE_CONF_DEVICE); +} + +static void SIEunconfigureDevice(void) { + // SIE Configure device command + SIECommand(SIE_CMD_CONFIGURE_DEVICE); + SIEWriteData(0); +} + +static void SIEconnect(void) { + // Connect USB device + uint8_t status = SIEgetDeviceStatus(); + SIEsetDeviceStatus(status | SIE_DS_CON); +} + + +static void SIEdisconnect(void) { + // Disconnect USB device + uint8_t status = SIEgetDeviceStatus(); + SIEsetDeviceStatus(status & ~SIE_DS_CON); +} + + +static uint8_t selectEndpointClearInterrupt(uint8_t endpoint) { + // Implemented using using EP_INT_CLR. + LPC_USB->USBEpIntClr = EP(endpoint); + while (!(LPC_USB->USBDevIntSt & CDFULL)); + return (uint8_t)LPC_USB->USBCmdData; +} + + +static void enableEndpointEvent(uint8_t endpoint) { + // Enable an endpoint interrupt + LPC_USB->USBEpIntEn |= EP(endpoint); +} + +static void disableEndpointEvent(uint8_t endpoint) __attribute__ ((unused)); +static void disableEndpointEvent(uint8_t endpoint) { + // Disable an endpoint interrupt + LPC_USB->USBEpIntEn &= ~EP(endpoint); +} + +static volatile uint32_t __attribute__((used)) dummyRead; +uint32_t USBHAL::endpointReadcore(uint8_t endpoint, uint8_t *buffer) { + // Read from an OUT endpoint + uint32_t size; + uint32_t i; + uint32_t data = 0; + uint8_t offset; + + LPC_USB->USBCtrl = LOG_ENDPOINT(endpoint) | RD_EN; + while (!(LPC_USB->USBRxPLen & PKT_RDY)); + + size = LPC_USB->USBRxPLen & PKT_LNGTH_MASK; + + offset = 0; + + if (size > 0) { + for (i=0; i<size; i++) { + if (offset==0) { + // Fetch up to four bytes of data as a word + data = LPC_USB->USBRxData; + } + + // extract a byte + *buffer = (data>>offset) & 0xff; + buffer++; + + // move on to the next byte + offset = (offset + 8) % 32; + } + } else { + dummyRead = LPC_USB->USBRxData; + } + + LPC_USB->USBCtrl = 0; + + if ((endpoint >> 1) % 3 || (endpoint >> 1) == 0) { + SIEselectEndpoint(endpoint); + SIEclearBuffer(); + } + + return size; +} + +static void endpointWritecore(uint8_t endpoint, uint8_t *buffer, uint32_t size) { + // Write to an IN endpoint + uint32_t temp, data; + uint8_t offset; + + LPC_USB->USBCtrl = LOG_ENDPOINT(endpoint) | WR_EN; + + LPC_USB->USBTxPLen = size; + offset = 0; + data = 0; + + if (size>0) { + do { + // Fetch next data byte into a word-sized temporary variable + temp = *buffer++; + + // Add to current data word + temp = temp << offset; + data = data | temp; + + // move on to the next byte + offset = (offset + 8) % 32; + size--; + + if ((offset==0) || (size==0)) { + // Write the word to the endpoint + LPC_USB->USBTxData = data; + data = 0; + } + } while (size>0); + } else { + LPC_USB->USBTxData = 0; + } + + // Clear WR_EN to cover zero length packet case + LPC_USB->USBCtrl=0; + + SIEselectEndpoint(endpoint); + SIEvalidateBuffer(); +} + +USBHAL::USBHAL(void) { + // Disable IRQ + NVIC_DisableIRQ(USB_IRQn); + + // fill in callback array + epCallback[0] = &USBHAL::EP1_OUT_callback; + epCallback[1] = &USBHAL::EP1_IN_callback; + epCallback[2] = &USBHAL::EP2_OUT_callback; + epCallback[3] = &USBHAL::EP2_IN_callback; + epCallback[4] = &USBHAL::EP3_OUT_callback; + epCallback[5] = &USBHAL::EP3_IN_callback; + epCallback[6] = &USBHAL::EP4_OUT_callback; + epCallback[7] = &USBHAL::EP4_IN_callback; + epCallback[8] = &USBHAL::EP5_OUT_callback; + epCallback[9] = &USBHAL::EP5_IN_callback; + epCallback[10] = &USBHAL::EP6_OUT_callback; + epCallback[11] = &USBHAL::EP6_IN_callback; + epCallback[12] = &USBHAL::EP7_OUT_callback; + epCallback[13] = &USBHAL::EP7_IN_callback; + epCallback[14] = &USBHAL::EP8_OUT_callback; + epCallback[15] = &USBHAL::EP8_IN_callback; + epCallback[16] = &USBHAL::EP9_OUT_callback; + epCallback[17] = &USBHAL::EP9_IN_callback; + epCallback[18] = &USBHAL::EP10_OUT_callback; + epCallback[19] = &USBHAL::EP10_IN_callback; + epCallback[20] = &USBHAL::EP11_OUT_callback; + epCallback[21] = &USBHAL::EP11_IN_callback; + epCallback[22] = &USBHAL::EP12_OUT_callback; + epCallback[23] = &USBHAL::EP12_IN_callback; + epCallback[24] = &USBHAL::EP13_OUT_callback; + epCallback[25] = &USBHAL::EP13_IN_callback; + epCallback[26] = &USBHAL::EP14_OUT_callback; + epCallback[27] = &USBHAL::EP14_IN_callback; + epCallback[28] = &USBHAL::EP15_OUT_callback; + epCallback[29] = &USBHAL::EP15_IN_callback; + + // Enable power to USB device controller + LPC_SC->PCONP |= PCUSB; + + // Enable USB clocks + LPC_USB->USBClkCtrl |= DEV_CLK_EN | AHB_CLK_EN; + while (LPC_USB->USBClkSt != (DEV_CLK_ON | AHB_CLK_ON)); + + // Configure pins P0.29 and P0.30 to be USB D+ and USB D- + LPC_PINCON->PINSEL1 &= 0xc3ffffff; + LPC_PINCON->PINSEL1 |= 0x14000000; + + // Disconnect USB device + SIEdisconnect(); + + // Configure pin P2.9 to be Connect + LPC_PINCON->PINSEL4 &= 0xfffcffff; + LPC_PINCON->PINSEL4 |= 0x00040000; + + // Connect must be low for at least 2.5uS + wait(0.3); + + // Set the maximum packet size for the control endpoints + realiseEndpoint(EP0IN, MAX_PACKET_SIZE_EP0, 0); + realiseEndpoint(EP0OUT, MAX_PACKET_SIZE_EP0, 0); + + // Attach IRQ + instance = this; + NVIC_SetVector(USB_IRQn, (uint32_t)&_usbisr); + + // Enable interrupts for device events and EP0 + LPC_USB->USBDevIntEn = EP_SLOW | DEV_STAT | FRAME; + enableEndpointEvent(EP0IN); + enableEndpointEvent(EP0OUT); +} + +USBHAL::~USBHAL(void) { + // Ensure device disconnected + SIEdisconnect(); + // Disable USB interrupts + NVIC_DisableIRQ(USB_IRQn); +} + +void USBHAL::connect(void) { + NVIC_EnableIRQ(USB_IRQn); + // Connect USB device + SIEconnect(); +} + +void USBHAL::disconnect(void) { + NVIC_DisableIRQ(USB_IRQn); + // Disconnect USB device + SIEdisconnect(); +} + +void USBHAL::configureDevice(void) { + SIEconfigureDevice(); +} + +void USBHAL::unconfigureDevice(void) { + SIEunconfigureDevice(); +} + +void USBHAL::setAddress(uint8_t address) { + SIEsetAddress(address); +} + +void USBHAL::EP0setup(uint8_t *buffer) { + endpointReadcore(EP0OUT, buffer); +} + +void USBHAL::EP0read(void) { + // Not required +} + +void USBHAL::EP0readStage(void) { + // Not required +} + +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) { + return endpointReadcore(EP0OUT, buffer); +} + +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) { + endpointWritecore(EP0IN, buffer, size); +} + +void USBHAL::EP0getWriteResult(void) { + // Not required +} + +void USBHAL::EP0stall(void) { + // This will stall both control endpoints + stallEndpoint(EP0OUT); +} + +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize) { + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t * buffer, uint32_t *bytesRead) { + + //for isochronous endpoint, we don't wait an interrupt + if ((endpoint >> 1) % 3 || (endpoint >> 1) == 0) { + if (!(epComplete & EP(endpoint))) + return EP_PENDING; + } + + *bytesRead = endpointReadcore(endpoint, buffer); + epComplete &= ~EP(endpoint); + return EP_COMPLETED; +} + +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) { + if (getEndpointStallState(endpoint)) { + return EP_STALLED; + } + + epComplete &= ~EP(endpoint); + + endpointWritecore(endpoint, data, size); + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) { + if (epComplete & EP(endpoint)) { + epComplete &= ~EP(endpoint); + return EP_COMPLETED; + } + + return EP_PENDING; +} + +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags) { + // Realise an endpoint + LPC_USB->USBDevIntClr = EP_RLZED; + LPC_USB->USBReEp |= EP(endpoint); + LPC_USB->USBEpInd = endpoint; + LPC_USB->USBMaxPSize = maxPacket; + + while (!(LPC_USB->USBDevIntSt & EP_RLZED)); + LPC_USB->USBDevIntClr = EP_RLZED; + + // Clear stall state + endpointStallState &= ~EP(endpoint); + + enableEndpointEvent(endpoint); + return true; +} + +void USBHAL::stallEndpoint(uint8_t endpoint) { + // Stall an endpoint + if ( (endpoint==EP0IN) || (endpoint==EP0OUT) ) { + // Conditionally stall both control endpoints + SIEsetEndpointStatus(EP0OUT, SIE_SES_CND_ST); + } else { + SIEsetEndpointStatus(endpoint, SIE_SES_ST); + + // Update stall state + endpointStallState |= EP(endpoint); + } +} + +void USBHAL::unstallEndpoint(uint8_t endpoint) { + // Unstall an endpoint. The endpoint will also be reinitialised + SIEsetEndpointStatus(endpoint, 0); + + // Update stall state + endpointStallState &= ~EP(endpoint); +} + +bool USBHAL::getEndpointStallState(uint8_t endpoint) { + // Returns true if endpoint stalled + return endpointStallState & EP(endpoint); +} + +void USBHAL::remoteWakeup(void) { + // Remote wakeup + uint8_t status; + + // Enable USB clocks + LPC_USB->USBClkCtrl |= DEV_CLK_EN | AHB_CLK_EN; + while (LPC_USB->USBClkSt != (DEV_CLK_ON | AHB_CLK_ON)); + + status = SIEgetDeviceStatus(); + SIEsetDeviceStatus(status & ~SIE_DS_SUS); +} + +void USBHAL::_usbisr(void) { + instance->usbisr(); +} + + +void USBHAL::usbisr(void) { + uint8_t devStat; + + if (LPC_USB->USBDevIntSt & FRAME) { + // Start of frame event + SOF(SIEgetFrameNumber()); + // Clear interrupt status flag + LPC_USB->USBDevIntClr = FRAME; + } + + if (LPC_USB->USBDevIntSt & DEV_STAT) { + // Device Status interrupt + // Must clear the interrupt status flag before reading the device status from the SIE + LPC_USB->USBDevIntClr = DEV_STAT; + + // Read device status from SIE + devStat = SIEgetDeviceStatus(); + //printf("devStat: %d\r\n", devStat); + + if (devStat & SIE_DS_SUS_CH) { + // Suspend status changed + if((devStat & SIE_DS_SUS) != 0) { + suspendStateChanged(0); + } + } + + if (devStat & SIE_DS_RST) { + // Bus reset + if((devStat & SIE_DS_SUS) == 0) { + suspendStateChanged(1); + } + busReset(); + } + } + + if (LPC_USB->USBDevIntSt & EP_SLOW) { + // (Slow) Endpoint Interrupt + + // Process each endpoint interrupt + if (LPC_USB->USBEpIntSt & EP(EP0OUT)) { + if (selectEndpointClearInterrupt(EP0OUT) & SIE_SE_STP) { + // this is a setup packet + EP0setupCallback(); + } else { + EP0out(); + } + LPC_USB->USBDevIntClr = EP_SLOW; + } + + if (LPC_USB->USBEpIntSt & EP(EP0IN)) { + selectEndpointClearInterrupt(EP0IN); + LPC_USB->USBDevIntClr = EP_SLOW; + EP0in(); + } + + for (uint8_t num = 2; num < 16*2; num++) { + if (LPC_USB->USBEpIntSt & EP(num)) { + selectEndpointClearInterrupt(num); + epComplete |= EP(num); + LPC_USB->USBDevIntClr = EP_SLOW; + if ((instance->*(epCallback[num - 2]))()) { + epComplete &= ~EP(num); + } + } + } + } +} + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC40.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC40.cpp new file mode 100644 index 000000000..a5d7b4440 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC40.cpp @@ -0,0 +1,628 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#if defined(TARGET_LPC4088) || defined(TARGET_LPC4088_DM) + +#include "USBHAL.h" + + +// Get endpoint direction +#define IN_EP(endpoint) ((endpoint) & 1U ? true : false) +#define OUT_EP(endpoint) ((endpoint) & 1U ? false : true) + +// Convert physical endpoint number to register bit +#define EP(endpoint) (1UL<<endpoint) + +// Power Control for Peripherals register +#define PCUSB (1UL<<31) + +// USB Clock Control register +#define DEV_CLK_EN (1UL<<1) +#define PORT_CLK_EN (1UL<<3) +#define AHB_CLK_EN (1UL<<4) + +// USB Clock Status register +#define DEV_CLK_ON (1UL<<1) +#define AHB_CLK_ON (1UL<<4) + +// USB Device Interupt registers +#define FRAME (1UL<<0) +#define EP_FAST (1UL<<1) +#define EP_SLOW (1UL<<2) +#define DEV_STAT (1UL<<3) +#define CCEMPTY (1UL<<4) +#define CDFULL (1UL<<5) +#define RxENDPKT (1UL<<6) +#define TxENDPKT (1UL<<7) +#define EP_RLZED (1UL<<8) +#define ERR_INT (1UL<<9) + +// USB Control register +#define RD_EN (1<<0) +#define WR_EN (1<<1) +#define LOG_ENDPOINT(endpoint) ((endpoint>>1)<<2) + +// USB Receive Packet Length register +#define DV (1UL<<10) +#define PKT_RDY (1UL<<11) +#define PKT_LNGTH_MASK (0x3ff) + +// Serial Interface Engine (SIE) +#define SIE_WRITE (0x01) +#define SIE_READ (0x02) +#define SIE_COMMAND (0x05) +#define SIE_CMD_CODE(phase, data) ((phase<<8)|(data<<16)) + +// SIE Command codes +#define SIE_CMD_SET_ADDRESS (0xD0) +#define SIE_CMD_CONFIGURE_DEVICE (0xD8) +#define SIE_CMD_SET_MODE (0xF3) +#define SIE_CMD_READ_FRAME_NUMBER (0xF5) +#define SIE_CMD_READ_TEST_REGISTER (0xFD) +#define SIE_CMD_SET_DEVICE_STATUS (0xFE) +#define SIE_CMD_GET_DEVICE_STATUS (0xFE) +#define SIE_CMD_GET_ERROR_CODE (0xFF) +#define SIE_CMD_READ_ERROR_STATUS (0xFB) + +#define SIE_CMD_SELECT_ENDPOINT(endpoint) (0x00+endpoint) +#define SIE_CMD_SELECT_ENDPOINT_CLEAR_INTERRUPT(endpoint) (0x40+endpoint) +#define SIE_CMD_SET_ENDPOINT_STATUS(endpoint) (0x40+endpoint) + +#define SIE_CMD_CLEAR_BUFFER (0xF2) +#define SIE_CMD_VALIDATE_BUFFER (0xFA) + +// SIE Device Status register +#define SIE_DS_CON (1<<0) +#define SIE_DS_CON_CH (1<<1) +#define SIE_DS_SUS (1<<2) +#define SIE_DS_SUS_CH (1<<3) +#define SIE_DS_RST (1<<4) + +// SIE Device Set Address register +#define SIE_DSA_DEV_EN (1<<7) + +// SIE Configue Device register +#define SIE_CONF_DEVICE (1<<0) + +// Select Endpoint register +#define SIE_SE_FE (1<<0) +#define SIE_SE_ST (1<<1) +#define SIE_SE_STP (1<<2) +#define SIE_SE_PO (1<<3) +#define SIE_SE_EPN (1<<4) +#define SIE_SE_B_1_FULL (1<<5) +#define SIE_SE_B_2_FULL (1<<6) + +// Set Endpoint Status command +#define SIE_SES_ST (1<<0) +#define SIE_SES_DA (1<<5) +#define SIE_SES_RF_MO (1<<6) +#define SIE_SES_CND_ST (1<<7) + + +USBHAL * USBHAL::instance; + +static volatile int epComplete; +static uint32_t endpointStallState; + +static void SIECommand(uint32_t command) { + // The command phase of a SIE transaction + LPC_USB->DevIntClr = CCEMPTY; + LPC_USB->CmdCode = SIE_CMD_CODE(SIE_COMMAND, command); + while (!(LPC_USB->DevIntSt & CCEMPTY)); +} + +static void SIEWriteData(uint8_t data) { + // The data write phase of a SIE transaction + LPC_USB->DevIntClr = CCEMPTY; + LPC_USB->CmdCode = SIE_CMD_CODE(SIE_WRITE, data); + while (!(LPC_USB->DevIntSt & CCEMPTY)); +} + +static uint8_t SIEReadData(uint32_t command) { + // The data read phase of a SIE transaction + LPC_USB->DevIntClr = CDFULL; + LPC_USB->CmdCode = SIE_CMD_CODE(SIE_READ, command); + while (!(LPC_USB->DevIntSt & CDFULL)); + return (uint8_t)LPC_USB->CmdData; +} + +static void SIEsetDeviceStatus(uint8_t status) { + // Write SIE device status register + SIECommand(SIE_CMD_SET_DEVICE_STATUS); + SIEWriteData(status); +} + +static uint8_t SIEgetDeviceStatus(void) { + // Read SIE device status register + SIECommand(SIE_CMD_GET_DEVICE_STATUS); + return SIEReadData(SIE_CMD_GET_DEVICE_STATUS); +} + +void SIEsetAddress(uint8_t address) { + // Write SIE device address register + SIECommand(SIE_CMD_SET_ADDRESS); + SIEWriteData((address & 0x7f) | SIE_DSA_DEV_EN); +} + +static uint8_t SIEselectEndpoint(uint8_t endpoint) { + // SIE select endpoint command + SIECommand(SIE_CMD_SELECT_ENDPOINT(endpoint)); + return SIEReadData(SIE_CMD_SELECT_ENDPOINT(endpoint)); +} + +static uint8_t SIEclearBuffer(void) { + // SIE clear buffer command + SIECommand(SIE_CMD_CLEAR_BUFFER); + return SIEReadData(SIE_CMD_CLEAR_BUFFER); +} + +static void SIEvalidateBuffer(void) { + // SIE validate buffer command + SIECommand(SIE_CMD_VALIDATE_BUFFER); +} + +static void SIEsetEndpointStatus(uint8_t endpoint, uint8_t status) { + // SIE set endpoint status command + SIECommand(SIE_CMD_SET_ENDPOINT_STATUS(endpoint)); + SIEWriteData(status); +} + +static uint16_t SIEgetFrameNumber(void) __attribute__ ((unused)); +static uint16_t SIEgetFrameNumber(void) { + // Read current frame number + uint16_t lowByte; + uint16_t highByte; + + SIECommand(SIE_CMD_READ_FRAME_NUMBER); + lowByte = SIEReadData(SIE_CMD_READ_FRAME_NUMBER); + highByte = SIEReadData(SIE_CMD_READ_FRAME_NUMBER); + + return (highByte << 8) | lowByte; +} + +static void SIEconfigureDevice(void) { + // SIE Configure device command + SIECommand(SIE_CMD_CONFIGURE_DEVICE); + SIEWriteData(SIE_CONF_DEVICE); +} + +static void SIEunconfigureDevice(void) { + // SIE Configure device command + SIECommand(SIE_CMD_CONFIGURE_DEVICE); + SIEWriteData(0); +} + +static void SIEconnect(void) { + // Connect USB device + uint8_t status = SIEgetDeviceStatus(); + SIEsetDeviceStatus(status | SIE_DS_CON); +} + + +static void SIEdisconnect(void) { + // Disconnect USB device + uint8_t status = SIEgetDeviceStatus(); + SIEsetDeviceStatus(status & ~SIE_DS_CON); +} + + +static uint8_t selectEndpointClearInterrupt(uint8_t endpoint) { + // Implemented using using EP_INT_CLR. + LPC_USB->EpIntClr = EP(endpoint); + while (!(LPC_USB->DevIntSt & CDFULL)); + return (uint8_t)LPC_USB->CmdData; +} + + +static void enableEndpointEvent(uint8_t endpoint) { + // Enable an endpoint interrupt + LPC_USB->EpIntEn |= EP(endpoint); +} + +static void disableEndpointEvent(uint8_t endpoint) __attribute__ ((unused)); +static void disableEndpointEvent(uint8_t endpoint) { + // Disable an endpoint interrupt + LPC_USB->EpIntEn &= ~EP(endpoint); +} + +static volatile uint32_t __attribute__((used)) dummyRead; +uint32_t USBHAL::endpointReadcore(uint8_t endpoint, uint8_t *buffer) { + // Read from an OUT endpoint + uint32_t size; + uint32_t i; + uint32_t data = 0; + uint8_t offset; + + LPC_USB->Ctrl = LOG_ENDPOINT(endpoint) | RD_EN; + while (!(LPC_USB->RxPLen & PKT_RDY)); + + size = LPC_USB->RxPLen & PKT_LNGTH_MASK; + + offset = 0; + + if (size > 0) { + for (i=0; i<size; i++) { + if (offset==0) { + // Fetch up to four bytes of data as a word + data = LPC_USB->RxData; + } + + // extract a byte + *buffer = (data>>offset) & 0xff; + buffer++; + + // move on to the next byte + offset = (offset + 8) % 32; + } + } else { + dummyRead = LPC_USB->RxData; + } + + LPC_USB->Ctrl = 0; + + if ((endpoint >> 1) % 3 || (endpoint >> 1) == 0) { + SIEselectEndpoint(endpoint); + SIEclearBuffer(); + } + + return size; +} + +static void endpointWritecore(uint8_t endpoint, uint8_t *buffer, uint32_t size) { + // Write to an IN endpoint + uint32_t temp, data; + uint8_t offset; + + LPC_USB->Ctrl = LOG_ENDPOINT(endpoint) | WR_EN; + + LPC_USB->TxPLen = size; + offset = 0; + data = 0; + + if (size>0) { + do { + // Fetch next data byte into a word-sized temporary variable + temp = *buffer++; + + // Add to current data word + temp = temp << offset; + data = data | temp; + + // move on to the next byte + offset = (offset + 8) % 32; + size--; + + if ((offset==0) || (size==0)) { + // Write the word to the endpoint + LPC_USB->TxData = data; + data = 0; + } + } while (size>0); + } else { + LPC_USB->TxData = 0; + } + + // Clear WR_EN to cover zero length packet case + LPC_USB->Ctrl=0; + + SIEselectEndpoint(endpoint); + SIEvalidateBuffer(); +} + +USBHAL::USBHAL(void) { + // Disable IRQ + NVIC_DisableIRQ(USB_IRQn); + + // fill in callback array + epCallback[0] = &USBHAL::EP1_OUT_callback; + epCallback[1] = &USBHAL::EP1_IN_callback; + epCallback[2] = &USBHAL::EP2_OUT_callback; + epCallback[3] = &USBHAL::EP2_IN_callback; + epCallback[4] = &USBHAL::EP3_OUT_callback; + epCallback[5] = &USBHAL::EP3_IN_callback; + epCallback[6] = &USBHAL::EP4_OUT_callback; + epCallback[7] = &USBHAL::EP4_IN_callback; + epCallback[8] = &USBHAL::EP5_OUT_callback; + epCallback[9] = &USBHAL::EP5_IN_callback; + epCallback[10] = &USBHAL::EP6_OUT_callback; + epCallback[11] = &USBHAL::EP6_IN_callback; + epCallback[12] = &USBHAL::EP7_OUT_callback; + epCallback[13] = &USBHAL::EP7_IN_callback; + epCallback[14] = &USBHAL::EP8_OUT_callback; + epCallback[15] = &USBHAL::EP8_IN_callback; + epCallback[16] = &USBHAL::EP9_OUT_callback; + epCallback[17] = &USBHAL::EP9_IN_callback; + epCallback[18] = &USBHAL::EP10_OUT_callback; + epCallback[19] = &USBHAL::EP10_IN_callback; + epCallback[20] = &USBHAL::EP11_OUT_callback; + epCallback[21] = &USBHAL::EP11_IN_callback; + epCallback[22] = &USBHAL::EP12_OUT_callback; + epCallback[23] = &USBHAL::EP12_IN_callback; + epCallback[24] = &USBHAL::EP13_OUT_callback; + epCallback[25] = &USBHAL::EP13_IN_callback; + epCallback[26] = &USBHAL::EP14_OUT_callback; + epCallback[27] = &USBHAL::EP14_IN_callback; + epCallback[28] = &USBHAL::EP15_OUT_callback; + epCallback[29] = &USBHAL::EP15_IN_callback; + + // Enable power to USB device controller + LPC_SC->PCONP |= PCUSB; + + // Enable USB clocks + LPC_USB->USBClkCtrl |= DEV_CLK_EN | AHB_CLK_EN | PORT_CLK_EN; + while ((LPC_USB->USBClkSt & (DEV_CLK_EN | AHB_CLK_EN | PORT_CLK_EN)) != (DEV_CLK_ON | AHB_CLK_ON | PORT_CLK_EN)); + + // Select port USB2 + LPC_USB->StCtrl |= 3; + + + // Configure pin P0.31 to be USB2 + LPC_IOCON->P0_31 &= ~0x07; + LPC_IOCON->P0_31 |= 0x01; + + // Disconnect USB device + SIEdisconnect(); + + // Configure pin P0.14 to be Connect + LPC_IOCON->P0_14 &= ~0x07; + LPC_IOCON->P0_14 |= 0x03; + + // Connect must be low for at least 2.5uS + wait(0.3); + + // Set the maximum packet size for the control endpoints + realiseEndpoint(EP0IN, MAX_PACKET_SIZE_EP0, 0); + realiseEndpoint(EP0OUT, MAX_PACKET_SIZE_EP0, 0); + + // Attach IRQ + instance = this; + NVIC_SetVector(USB_IRQn, (uint32_t)&_usbisr); + + // Enable interrupts for device events and EP0 + LPC_USB->DevIntEn = EP_SLOW | DEV_STAT | FRAME; + enableEndpointEvent(EP0IN); + enableEndpointEvent(EP0OUT); +} + +USBHAL::~USBHAL(void) { + // Ensure device disconnected + SIEdisconnect(); + // Disable USB interrupts + NVIC_DisableIRQ(USB_IRQn); +} + +void USBHAL::connect(void) { + NVIC_EnableIRQ(USB_IRQn); + // Connect USB device + SIEconnect(); +} + +void USBHAL::disconnect(void) { + NVIC_DisableIRQ(USB_IRQn); + // Disconnect USB device + SIEdisconnect(); +} + +void USBHAL::configureDevice(void) { + SIEconfigureDevice(); +} + +void USBHAL::unconfigureDevice(void) { + SIEunconfigureDevice(); +} + +void USBHAL::setAddress(uint8_t address) { + SIEsetAddress(address); +} + +void USBHAL::EP0setup(uint8_t *buffer) { + endpointReadcore(EP0OUT, buffer); +} + +void USBHAL::EP0read(void) { + // Not required +} + +void USBHAL::EP0readStage(void) { + // Not required +} + +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) { + return endpointReadcore(EP0OUT, buffer); +} + +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) { + endpointWritecore(EP0IN, buffer, size); +} + +void USBHAL::EP0getWriteResult(void) { + // Not required +} + +void USBHAL::EP0stall(void) { + // This will stall both control endpoints + stallEndpoint(EP0OUT); +} + +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize) { + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t * buffer, uint32_t *bytesRead) { + + //for isochronous endpoint, we don't wait an interrupt + if ((endpoint >> 1) % 3 || (endpoint >> 1) == 0) { + if (!(epComplete & EP(endpoint))) + return EP_PENDING; + } + + *bytesRead = endpointReadcore(endpoint, buffer); + epComplete &= ~EP(endpoint); + return EP_COMPLETED; +} + +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) { + if (getEndpointStallState(endpoint)) { + return EP_STALLED; + } + + epComplete &= ~EP(endpoint); + + endpointWritecore(endpoint, data, size); + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) { + if (epComplete & EP(endpoint)) { + epComplete &= ~EP(endpoint); + return EP_COMPLETED; + } + + return EP_PENDING; +} + +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags) { + // Realise an endpoint + LPC_USB->DevIntClr = EP_RLZED; + LPC_USB->ReEp |= EP(endpoint); + LPC_USB->EpInd = endpoint; + LPC_USB->MaxPSize = maxPacket; + + while (!(LPC_USB->DevIntSt & EP_RLZED)); + LPC_USB->DevIntClr = EP_RLZED; + + // Clear stall state + endpointStallState &= ~EP(endpoint); + + enableEndpointEvent(endpoint); + return true; +} + +void USBHAL::stallEndpoint(uint8_t endpoint) { + // Stall an endpoint + if ( (endpoint==EP0IN) || (endpoint==EP0OUT) ) { + // Conditionally stall both control endpoints + SIEsetEndpointStatus(EP0OUT, SIE_SES_CND_ST); + } else { + SIEsetEndpointStatus(endpoint, SIE_SES_ST); + + // Update stall state + endpointStallState |= EP(endpoint); + } +} + +void USBHAL::unstallEndpoint(uint8_t endpoint) { + // Unstall an endpoint. The endpoint will also be reinitialised + SIEsetEndpointStatus(endpoint, 0); + + // Update stall state + endpointStallState &= ~EP(endpoint); +} + +bool USBHAL::getEndpointStallState(uint8_t endpoint) { + // Returns true if endpoint stalled + return endpointStallState & EP(endpoint); +} + +void USBHAL::remoteWakeup(void) { + // Remote wakeup + uint8_t status; + + // Enable USB clocks + LPC_USB->USBClkCtrl |= DEV_CLK_EN | AHB_CLK_EN; + while (LPC_USB->USBClkSt != (DEV_CLK_ON | AHB_CLK_ON)); + + status = SIEgetDeviceStatus(); + SIEsetDeviceStatus(status & ~SIE_DS_SUS); +} + +void USBHAL::_usbisr(void) { + instance->usbisr(); +} + + +void USBHAL::usbisr(void) { + uint8_t devStat; + + if (LPC_USB->DevIntSt & FRAME) { + // Start of frame event + SOF(SIEgetFrameNumber()); + // Clear interrupt status flag + LPC_USB->DevIntClr = FRAME; + } + + if (LPC_USB->DevIntSt & DEV_STAT) { + // Device Status interrupt + // Must clear the interrupt status flag before reading the device status from the SIE + LPC_USB->DevIntClr = DEV_STAT; + + // Read device status from SIE + devStat = SIEgetDeviceStatus(); + //printf("devStat: %d\r\n", devStat); + + if (devStat & SIE_DS_SUS_CH) { + // Suspend status changed + if((devStat & SIE_DS_SUS) != 0) { + suspendStateChanged(0); + } + } + + if (devStat & SIE_DS_RST) { + // Bus reset + if((devStat & SIE_DS_SUS) == 0) { + suspendStateChanged(1); + } + busReset(); + } + } + + if (LPC_USB->DevIntSt & EP_SLOW) { + // (Slow) Endpoint Interrupt + + // Process each endpoint interrupt + if (LPC_USB->EpIntSt & EP(EP0OUT)) { + if (selectEndpointClearInterrupt(EP0OUT) & SIE_SE_STP) { + // this is a setup packet + EP0setupCallback(); + } else { + EP0out(); + } + LPC_USB->DevIntClr = EP_SLOW; + } + + if (LPC_USB->EpIntSt & EP(EP0IN)) { + selectEndpointClearInterrupt(EP0IN); + LPC_USB->DevIntClr = EP_SLOW; + EP0in(); + } + + for (uint8_t num = 2; num < 16*2; num++) { + if (LPC_USB->EpIntSt & EP(num)) { + selectEndpointClearInterrupt(num); + epComplete |= EP(num); + LPC_USB->DevIntClr = EP_SLOW; + if ((instance->*(epCallback[num - 2]))()) { + epComplete &= ~EP(num); + } + } + } + } +} + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp new file mode 100644 index 000000000..13e193cd2 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp @@ -0,0 +1,473 @@ +/******************************************************************************* + * Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES + * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of Maxim Integrated + * Products, Inc. shall not be used except as stated in the Maxim Integrated + * Products, Inc. Branding Policy. + * + * The mere transfer of this software does not imply any licenses + * of trade secrets, proprietary technology, copyrights, patents, + * trademarks, maskwork rights, or any other form of intellectual + * property whatsoever. Maxim Integrated Products, Inc. retains all + * ownership rights. + ******************************************************************************* + */ + +#if defined(TARGET_Maxim) + +#include "USBHAL.h" +#include "usb_regs.h" +#include "clkman_regs.h" + +#define CONNECT_INTS (MXC_F_USB_DEV_INTEN_BRST | MXC_F_USB_DEV_INTEN_SETUP | MXC_F_USB_DEV_INTEN_EP_IN | MXC_F_USB_DEV_INTEN_EP_OUT | MXC_F_USB_DEV_INTEN_DMA_ERR) + +USBHAL *USBHAL::instance; + +typedef struct { + volatile uint32_t buf0_desc; + volatile uint32_t buf0_address; + volatile uint32_t buf1_desc; + volatile uint32_t buf1_address; +} ep_buffer_t; + +typedef struct { + ep_buffer_t out_buffer; + ep_buffer_t in_buffer; +} ep0_buffer_t; + +typedef struct { + ep0_buffer_t ep0; + ep_buffer_t ep[MXC_USB_NUM_EP - 1]; +} ep_buffer_descriptor_t; + +// Static storage for endpoint buffer descriptor table. Must be 512 byte alligned for DMA. +#ifdef __IAR_SYSTEMS_ICC__ +#pragma data_alignment = 512 +#else +__attribute__ ((aligned (512))) +#endif +ep_buffer_descriptor_t ep_buffer_descriptor; + +// static storage for temporary data buffers. Must be 32 byte alligned. +#ifdef __IAR_SYSTEMS_ICC__ +#pragma data_alignment = 4 +#else +__attribute__ ((aligned (4))) +#endif +static uint8_t aligned_buffer[NUMBER_OF_LOGICAL_ENDPOINTS][MXC_USB_MAX_PACKET]; + +// contorl packet state +static enum { + CTRL_NONE = 0, + CTRL_SETUP, + CTRL_OUT, + CTRL_IN, +} control_state; + +USBHAL::USBHAL(void) +{ + NVIC_DisableIRQ(USB_IRQn); + + // The PLL must be enabled for USB + MBED_ASSERT(MXC_CLKMAN->clk_config & MXC_F_CLKMAN_CLK_CONFIG_PLL_ENABLE); + + // Enable the USB clock + MXC_CLKMAN->clk_ctrl |= MXC_F_CLKMAN_CLK_CTRL_USB_GATE_N; + + // reset the device + MXC_USB->cn = 0; + MXC_USB->cn = 1; + MXC_USB->dev_inten = 0; + MXC_USB->dev_cn = 0; + MXC_USB->dev_cn = MXC_F_USB_DEV_CN_URST; + MXC_USB->dev_cn = 0; + + // fill in callback arrays + epCallback[EP0OUT] = NULL; + epCallback[EP0IN] = NULL; + epCallback[EP1OUT] = &USBHAL::EP1_OUT_callback; + epCallback[EP1IN ] = &USBHAL::EP1_IN_callback; + epCallback[EP2OUT] = &USBHAL::EP2_OUT_callback; + epCallback[EP2IN ] = &USBHAL::EP2_IN_callback; + epCallback[EP3OUT] = &USBHAL::EP3_OUT_callback; + epCallback[EP3IN ] = &USBHAL::EP3_IN_callback; + epCallback[EP4OUT] = &USBHAL::EP4_OUT_callback; + epCallback[EP4IN ] = &USBHAL::EP4_IN_callback; + epCallback[EP5OUT] = &USBHAL::EP5_OUT_callback; + epCallback[EP5IN ] = &USBHAL::EP5_IN_callback; + epCallback[EP6OUT] = &USBHAL::EP6_OUT_callback; + epCallback[EP6IN ] = &USBHAL::EP6_IN_callback; + epCallback[EP7OUT] = &USBHAL::EP7_OUT_callback; + epCallback[EP7IN ] = &USBHAL::EP7_IN_callback; + + // clear driver state + control_state = CTRL_NONE; + + // set the descriptor location + MXC_USB->ep_base = (uint32_t)&ep_buffer_descriptor; + + // attach IRQ handler and enable interrupts + instance = this; + NVIC_SetVector(USB_IRQn, (uint32_t)&_usbisr); + NVIC_EnableIRQ(USB_IRQn); +} + +USBHAL::~USBHAL(void) +{ + MXC_USB->dev_cn = MXC_F_USB_DEV_CN_URST; + MXC_USB->dev_cn = 0; + MXC_USB->cn = 0; +} + +void USBHAL::connect(void) +{ + // enable interrupts + MXC_USB->dev_inten |= CONNECT_INTS; + + // allow interrupts on ep0 + MXC_USB->ep[0] |= MXC_F_USB_EP_INT_EN; + + // pullup enable + MXC_USB->dev_cn |= (MXC_F_USB_DEV_CN_CONNECT | MXC_F_USB_DEV_CN_FIFO_MODE); +} + +void USBHAL::disconnect(void) +{ + // disable interrupts + MXC_USB->dev_inten &= ~CONNECT_INTS; + + // disable pullup + MXC_USB->dev_cn &= ~MXC_F_USB_DEV_CN_CONNECT; +} + +void USBHAL::configureDevice(void) +{ + // do nothing +} + +void USBHAL::unconfigureDevice(void) +{ + // reset endpoints + for (int i = 0; i < MXC_USB_NUM_EP; i++) { + // Disable endpoint and clear the data toggle + MXC_USB->ep[i] &= ~MXC_F_USB_EP_DIR; + MXC_USB->ep[i] |= MXC_F_USB_EP_DT; + } +} + +void USBHAL::setAddress(uint8_t address) +{ + // do nothing +} + +void USBHAL::remoteWakeup(void) +{ + // do nothing +} + +static ep_buffer_t *get_desc(uint8_t endpoint) +{ + uint8_t epnum = EP_NUM(endpoint); + ep_buffer_t *desc; + + if (epnum == 0) { + if (IN_EP(endpoint)) { + desc = &ep_buffer_descriptor.ep0.in_buffer; + } else { + desc = &ep_buffer_descriptor.ep0.out_buffer; + } + } else { + desc = &ep_buffer_descriptor.ep[epnum - 1]; + } + + return desc; +} + +void USBHAL::EP0setup(uint8_t *buffer) +{ + memcpy(buffer, (void*)&MXC_USB->setup0, 8); // setup packet is fixed at 8 bytes +} + +void USBHAL::EP0read(void) +{ + if (control_state == CTRL_IN) { + // This is the status stage. ACK. + MXC_USB->ep[0] |= MXC_F_USB_EP_ST_ACK; + control_state = CTRL_NONE; + return; + } + + control_state = CTRL_OUT; + + endpointRead(EP0OUT, MAX_PACKET_SIZE_EP0); +} + +void USBHAL::EP0readStage(void) +{ + // do nothing +} + +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) +{ + uint32_t size; + + if (MXC_USB->out_owner & 1) { + return 0; + } + + // get the packet length and contents + ep_buffer_t *desc = get_desc(EP0OUT); + size = desc->buf0_desc; + memcpy(buffer, aligned_buffer[0], size); + + return size; +} + +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) +{ + if ((size == 0) && (control_state != CTRL_IN)) { + // This is a status stage ACK. Handle in hardware. + MXC_USB->ep[0] |= MXC_F_USB_EP_ST_ACK; + control_state = CTRL_NONE; + return; + } + + control_state = CTRL_IN; + + endpointWrite(EP0IN, buffer, size); +} + +void USBHAL::EP0stall(void) +{ + stallEndpoint(0); +} + +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize) +{ + uint8_t epnum = EP_NUM(endpoint); + + if ((endpoint >= NUMBER_OF_PHYSICAL_ENDPOINTS) || IN_EP(endpoint)) { + return EP_INVALID; + } + + if (maximumSize > MXC_USB_MAX_PACKET) { + return EP_INVALID; + } + + uint32_t mask = (1 << epnum); + if (MXC_USB->out_owner & mask) { + return EP_INVALID; + } + + ep_buffer_t *desc = get_desc(endpoint); + desc->buf0_desc = maximumSize; + desc->buf0_address = (uint32_t)aligned_buffer[epnum]; + + MXC_USB->out_owner = mask; + + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t *data, uint32_t *bytesRead) +{ + if ((endpoint >= NUMBER_OF_PHYSICAL_ENDPOINTS) || IN_EP(endpoint)) { + return EP_INVALID; + } + + uint32_t mask = (1 << EP_NUM(endpoint)); + if (MXC_USB->out_owner & mask) { + return EP_PENDING; + } + + // get the packet length and contents + ep_buffer_t *desc = get_desc(endpoint); + *bytesRead = desc->buf0_desc; + memcpy(data, aligned_buffer[EP_NUM(endpoint)], *bytesRead); + + return EP_COMPLETED; +} + +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) +{ + uint8_t epnum = EP_NUM(endpoint); + + if ((endpoint >= NUMBER_OF_PHYSICAL_ENDPOINTS) || OUT_EP(endpoint)) { + return EP_INVALID; + } + + if (size > MXC_USB_MAX_PACKET) { + return EP_INVALID; + } + + uint32_t mask = (1 << epnum); + if (MXC_USB->in_owner & mask) { + return EP_INVALID; + } + + memcpy(aligned_buffer[epnum], data, size); + + ep_buffer_t *desc = get_desc(endpoint); + desc->buf0_desc = size; + desc->buf0_address = (uint32_t)aligned_buffer[epnum]; + + // start the DMA + MXC_USB->in_owner = mask; + + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) +{ + uint32_t mask = (1 << EP_NUM(endpoint)); + if (MXC_USB->in_owner & mask) { + return EP_PENDING; + } + + return EP_COMPLETED; +} + +void USBHAL::stallEndpoint(uint8_t endpoint) +{ + uint8_t epnum = EP_NUM(endpoint); + + if (epnum == 0) { + MXC_USB->ep[epnum] |= MXC_F_USB_EP_ST_STALL; + } + + MXC_USB->ep[epnum] |= MXC_F_USB_EP_STALL; +} + +void USBHAL::unstallEndpoint(uint8_t endpoint) +{ + MXC_USB->ep[EP_NUM(endpoint)] &= ~MXC_F_USB_EP_STALL; +} + +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t options) +{ + uint8_t epnum = EP_NUM(endpoint); + uint32_t ep_ctrl; + + if (epnum >= NUMBER_OF_PHYSICAL_ENDPOINTS) { + return false; + } + + if (IN_EP(endpoint)) { + ep_ctrl = (MXC_V_USB_EP_DIR_IN << MXC_F_USB_EP_DIR_POS); + } else { + ep_ctrl = (MXC_S_USB_EP_DIR_OUT << MXC_F_USB_EP_DIR_POS); + } + + ep_ctrl |= (MXC_F_USB_EP_DT | MXC_F_USB_EP_INT_EN); + + MXC_USB->ep[epnum] = ep_ctrl; + + return true; +} + +bool USBHAL::getEndpointStallState(unsigned char endpoint) +{ + return !!(MXC_USB->ep[endpoint] & MXC_F_USB_EP_STALL); +} + +void USBHAL::_usbisr(void) +{ + instance->usbisr(); +} + +void USBHAL::usbisr(void) +{ + // get and clear irqs + uint32_t irq_flags = MXC_USB->dev_intfl; + MXC_USB->dev_intfl = irq_flags; + + // process only enabled interrupts + irq_flags &= MXC_USB->dev_inten; + + // suspend + if (irq_flags & MXC_F_USB_DEV_INTFL_SUSP) { + suspendStateChanged(1); + } + + // bus reset + if (irq_flags & MXC_F_USB_DEV_INTFL_BRST) { + + // reset endpoints + for (int i = 0; i < MXC_USB_NUM_EP; i++) { + // Disable endpoint and clear the data toggle + MXC_USB->ep[i] &= ~MXC_F_USB_EP_DIR; + MXC_USB->ep[i] |= MXC_F_USB_EP_DT; + } + + // clear driver state + control_state = CTRL_NONE; + + busReset(); + + // no need to process events after reset + return; + } + + // Setup packet + if (irq_flags & MXC_F_USB_DEV_INTFL_SETUP) { + control_state = CTRL_SETUP; + EP0setupCallback(); + } + + // IN packets + if (irq_flags & MXC_F_USB_DEV_INTFL_EP_IN) { + // get and clear IN irqs + uint32_t in_irqs = MXC_USB->in_int; + MXC_USB->in_int = in_irqs; + + if (in_irqs & 1) { + EP0in(); + } + + for (uint8_t epnum = 1; epnum < NUMBER_OF_LOGICAL_ENDPOINTS; epnum++) { + uint32_t irq_mask = (1 << epnum); + if (in_irqs & irq_mask) { + uint8_t endpoint = (epnum << 1) | DIR_IN; + (instance->*(epCallback[endpoint]))(); + } + } + } + + // OUT packets + if (irq_flags & MXC_F_USB_DEV_INTFL_EP_OUT) { + // get and clear OUT irqs + uint32_t out_irqs = MXC_USB->out_int; + MXC_USB->out_int = out_irqs; + + if (out_irqs & 1) { + EP0out(); + } + + for (uint8_t epnum = 1; epnum < NUMBER_OF_LOGICAL_ENDPOINTS; epnum++) { + uint32_t irq_mask = (1 << epnum); + if (out_irqs & irq_mask) { + uint8_t endpoint = (epnum << 1) | DIR_OUT; + (instance->*(epCallback[endpoint]))(); + } + } + } +} + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp new file mode 100644 index 000000000..5eee82a64 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp @@ -0,0 +1,1497 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person +* obtaining a copy of this software and associated documentation +* files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, +* copy, modify, merge, publish, distribute, sublicense, and/or +* sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following +* conditions: +* +* The above copyright notice and this permission notice shall be +* included in all copies or substantial portions of the +* Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +* KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +* PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#if defined(TARGET_RZ_A1H) + +/* + This class can use the pipe1, pipe3 and pipe6 only. You should + re-program this class if you wanted to use other pipe. + */ + +/*************************************************************************/ +extern "C" +{ +#include "r_typedefs.h" +#include "iodefine.h" +} +#include "USBHAL.h" +#include "devdrv_usb_function_api.h" +#include "usb_iobitmask.h" +#include "rza_io_regrw.h" +#include "USBDevice_Types.h" +#include "usb_function_setting.h" + + +/*************************************************************************/ +/* constants */ +const struct PIPECFGREC { + uint16_t endpoint; + uint16_t pipesel; + uint16_t pipecfg; + uint16_t pipebuf; + uint16_t pipemaxp; + uint16_t pipeperi; +} def_pipecfg[] = { + /*EP0OUT and EP0IN are configured by USB IP*/ + { + EP1OUT, /*EP1: Host -> Func, INT*/ + 6 | USB_FUNCTION_D0FIFO_USE, + USB_FUNCTION_INTERRUPT | + USB_FUNCTION_BFREOFF | + USB_FUNCTION_DBLBOFF | + USB_FUNCTION_CNTMDON | + USB_FUNCTION_SHTNAKOFF | + USB_FUNCTION_DIR_P_OUT | + USB_FUNCTION_EP1, + ( ( ( 64) / 64 - 1 ) << 10 ) | 0x04u, + MAX_PACKET_SIZE_EP1, + DEVDRV_USBF_OFF | + ( 3 << USB_PIPEPERI_IITV_SHIFT ), + }, + { + EP1IN, /*EP1: Host <- Func, INT*/ + 7 | USB_FUNCTION_D1FIFO_USE, + USB_FUNCTION_INTERRUPT | + USB_FUNCTION_BFREOFF | + USB_FUNCTION_DBLBOFF | + USB_FUNCTION_CNTMDOFF | + USB_FUNCTION_SHTNAKOFF | + USB_FUNCTION_DIR_P_IN | + USB_FUNCTION_EP1, + ( ( ( 64) / 64 - 1 ) << 10 ) | 0x05u, + MAX_PACKET_SIZE_EP1, + DEVDRV_USBF_OFF | + ( 3 << USB_PIPEPERI_IITV_SHIFT ), + }, + { + EP2OUT, /*EP2: Host -> Func, BULK*/ + 3 | USB_FUNCTION_D0FIFO_USE, + USB_FUNCTION_BULK | + USB_FUNCTION_BFREOFF | + USB_FUNCTION_DBLBON | + USB_FUNCTION_CNTMDON | + USB_FUNCTION_SHTNAKON | + USB_FUNCTION_DIR_P_OUT | + USB_FUNCTION_EP2, + ( ( (2048) / 64 - 1 ) << 10 ) | 0x30u, + MAX_PACKET_SIZE_EP2, + DEVDRV_USBF_OFF | + ( 0 << USB_PIPEPERI_IITV_SHIFT ), + }, + { + EP2IN, /*EP2: Host <- Func, BULK*/ + 4 | USB_FUNCTION_D1FIFO_USE, + USB_FUNCTION_BULK | + USB_FUNCTION_BFREOFF | + USB_FUNCTION_DBLBOFF | + USB_FUNCTION_CNTMDON | + USB_FUNCTION_SHTNAKOFF | + USB_FUNCTION_DIR_P_IN | + USB_FUNCTION_EP2, + ( ( (2048) / 64 - 1 ) << 10 ) | 0x50u, + MAX_PACKET_SIZE_EP2, + DEVDRV_USBF_OFF | + ( 0 << USB_PIPEPERI_IITV_SHIFT ), + }, + { + EP3OUT, /*EP3: Host -> Func, ISO*/ + 1 | USB_FUNCTION_D0FIFO_USE, + USB_FUNCTION_ISO | + USB_FUNCTION_BFREOFF | + USB_FUNCTION_DBLBON | + USB_FUNCTION_CNTMDOFF | + USB_FUNCTION_SHTNAKON | + USB_FUNCTION_DIR_P_OUT | + USB_FUNCTION_EP3, + ( ( ( 512) / 64 - 1 ) << 10 ) | 0x10u, + MAX_PACKET_SIZE_EP3, + DEVDRV_USBF_OFF | + ( 0 << USB_PIPEPERI_IITV_SHIFT ), + }, + { + EP3IN, /*EP3: Host <- Func, ISO*/ + 2 | USB_FUNCTION_D1FIFO_USE, + USB_FUNCTION_ISO | + USB_FUNCTION_BFREOFF | + USB_FUNCTION_DBLBON | + USB_FUNCTION_CNTMDOFF | + USB_FUNCTION_SHTNAKOFF | + USB_FUNCTION_DIR_P_IN | + USB_FUNCTION_EP3, + ( ( ( 512) / 64 - 1 ) << 10 ) | 0x20u, + MAX_PACKET_SIZE_EP3, + DEVDRV_USBF_OFF | + ( 0 << USB_PIPEPERI_IITV_SHIFT ), + }, + { /*terminator*/ + 0, 0, 0, 0, 0, + }, +}; + + +/*************************************************************************/ +/* workareas */ +USBHAL * USBHAL::instance; + +static IRQn_Type int_id; /* interrupt ID */ +static uint16_t int_level; /* initerrupt level */ +static uint16_t clock_mode; /* input clock selector */ +static uint16_t mode; /* USB speed (HIGH/FULL) */ + +//static DigitalOut *usbx_en; + +static uint16_t EP0_read_status; +static uint16_t EPx_read_status; + +static uint16_t setup_buffer[MAX_PACKET_SIZE_EP0 / 2]; + +/* 0: not used / other: a pipe number to use recv_buffer*/ +static uint8_t recv_buffer[MAX_PACKET_SIZE_EPBULK]; +volatile static uint16_t recv_error; + + +/*************************************************************************/ +/* prototypes for C */ +extern "C" { + void usbx_function_BRDYInterruptPIPE0 (uint16_t status, uint16_t intenb, + USBHAL *object, void (USBHAL::*EP0func)(void)); + + void usbx_function_BRDYInterrupt (uint16_t status, uint16_t intenb, + USBHAL *object, bool (USBHAL::*epCallback[])(void)); + + void usbx_function_NRDYInterruptPIPE0(uint16_t status, uint16_t intenb, + USBHAL *object, void (USBHAL::*EP0func)(void)); + + void usbx_function_NRDYInterrupt (uint16_t status, uint16_t intenb, + USBHAL *object, bool (USBHAL::*epCallback[])(void)); + + void usbx_function_BEMPInterruptPIPE0(uint16_t status, uint16_t intenb, + USBHAL *object, void (USBHAL::*EP0func)(void)); + + void usbx_function_BEMPInterrupt (uint16_t status, uint16_t intenb, + USBHAL *object, bool (USBHAL::*epCallback[])(void)); +} + + +/*************************************************************************/ +/* macros */ + +/****************************************************************************** + * Function Name: usbx_function_BRDYInterruptPIPE0 + * Description : Executes BRDY interrupt for pipe0. + * Arguments : uint16_t status ; BRDYSTS Register Value + * : uint16_t intenb ; BRDYENB Register Value + * Return Value : none + *****************************************************************************/ +extern "C" { + void usbx_function_BRDYInterruptPIPE0 ( + uint16_t status, + uint16_t intenb, + USBHAL *object, + void (USBHAL::*EP0func)(void) + ) + { + volatile uint16_t dumy_sts; + uint16_t read_status; + + USB20X.BRDYSTS = + (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0]; + RZA_IO_RegWrite_16( + &USB20X.CFIFOSEL, USB_FUNCTION_PIPE0, + USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE); + + g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0] = + g_usbx_function_data_count[USB_FUNCTION_PIPE0]; + + read_status = usbx_function_read_buffer_c(USB_FUNCTION_PIPE0); + + g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0] -= + g_usbx_function_data_count[USB_FUNCTION_PIPE0]; + + switch (read_status) { + case USB_FUNCTION_READING: /* Continue of data read */ + case USB_FUNCTION_READEND: /* End of data read */ + /* PID = BUF */ + usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); + + /*callback*/ + (object->*EP0func)(); + break; + + case USB_FUNCTION_READSHRT: /* End of data read */ + usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0); + /* PID = BUF */ + usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); + + /*callback*/ + (object->*EP0func)(); + break; + + case USB_FUNCTION_READOVER: /* FIFO access error */ + /* Buffer Clear */ + USB20X.CFIFOCTR = USB_FUNCTION_BITBCLR; + usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0); + /* Req Error */ + usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); + + /*callback*/ + (object->*EP0func)(); + break; + + case DEVDRV_USBF_FIFOERROR: /* FIFO access error */ + default: + usbx_function_disable_brdy_int(USB_FUNCTION_PIPE0); + /* Req Error */ + usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); + break; + } + /* Three dummy reads for clearing interrupt requests */ + dumy_sts = USB20X.BRDYSTS; + } +} + + +/****************************************************************************** + * Function Name: usbx_function_BRDYInterrupt + * Description : Executes BRDY interrupt uxclude pipe0. + * Arguments : uint16_t status ; BRDYSTS Register Value + * : uint16_t intenb ; BRDYENB Register Value + * Return Value : none + *****************************************************************************/ +extern "C" { + void usbx_function_BRDYInterrupt( + uint16_t status, + uint16_t intenb, + USBHAL *object, + bool (USBHAL::*epCallback[])(void) + ) + { + volatile uint16_t dumy_sts; + + /************************************************************** + * Function Name: usbx_function_brdy_int + * Description : Executes BRDY interrupt(USB_FUNCTION_PIPE1-9). + * : According to the pipe that interrupt is generated in, + * : reads/writes buffer allocated in the pipe. + * : This function is executed in the BRDY + * : interrupt handler. This function + * : clears BRDY interrupt status and BEMP + * : interrupt status. + * Arguments : uint16_t Status ; BRDYSTS Register Value + * : uint16_t Int_enbl ; BRDYENB Register Value + * Return Value : none + *************************************************************/ + /* copied from usbx_function_intrn.c */ + uint32_t int_sense = 0; + uint16_t pipe; + uint16_t pipebit; + uint16_t ep; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) { + pipebit = g_usbx_function_bit_set[pipe]; + + if ((status & pipebit) && (intenb & pipebit)) { + USB20X.BRDYSTS = (uint16_t)~pipebit; + USB20X.BEMPSTS = (uint16_t)~pipebit; + + switch (g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) { + case USB_FUNCTION_D0FIFO_DMA: + if (g_usbx_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY) { + /*now, DMA is not supported*/ + usbx_function_dma_interrupt_d0fifo(int_sense); + } + + if (RZA_IO_RegRead_16( + &g_usbx_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) { + /*now, DMA is not supported*/ + usbx_function_read_dma(pipe); + usbx_function_disable_brdy_int(pipe); + } else { + USB20X.D0FIFOCTR = USB_FUNCTION_BITBCLR; + g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + break; + + case USB_FUNCTION_D1FIFO_DMA: + if (g_usbx_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY) { + /*now, DMA is not supported*/ + usbx_function_dma_interrupt_d1fifo(int_sense); + } + + if (RZA_IO_RegRead_16( + &g_usbx_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0) { + /*now, DMA is not supported*/ + usbx_function_read_dma(pipe); + usbx_function_disable_brdy_int(pipe); + } else { + USB20X.D1FIFOCTR = USB_FUNCTION_BITBCLR; + g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + } + break; + + default: + ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; + ep <<= 1; + if (RZA_IO_RegRead_16( + &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) { + /* read */ + EPx_read_status = DEVDRV_USBF_PIPE_WAIT; + (object->*(epCallback[ep - 2])) (); + EPx_read_status = DEVDRV_USBF_PIPE_DONE; + } else { + /* write */ + EPx_read_status = DEVDRV_USBF_PIPE_WAIT; + (object->*(epCallback[ep - 2 + 1])) (); + EPx_read_status = DEVDRV_USBF_PIPE_DONE; + usbx_function_write_buffer(pipe); + } + } + } + } + /* Three dummy reads for clearing interrupt requests */ + dumy_sts = USB20X.BRDYSTS; + } +} + + +/****************************************************************************** + * Function Name: usbx_function_NRDYInterruptPIPE0 + * Description : Executes NRDY interrupt for pipe0. + * Arguments : uint16_t status ; NRDYSTS Register Value + * : uint16_t intenb ; NRDYENB Register Value + * Return Value : none + *****************************************************************************/ +extern "C" { + void usbx_function_NRDYInterruptPIPE0( + uint16_t status, + uint16_t intenb, + USBHAL *object, + void (USBHAL::*EP0func)(void) + ) + { + volatile uint16_t dumy_sts; + + USB20X.NRDYSTS = + (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0]; + + /* Three dummy reads for clearing interrupt requests */ + dumy_sts = USB20X.NRDYSTS; + } +} + + +/****************************************************************************** + * Function Name: usbx_function_NRDYInterrupt + * Description : Executes NRDY interrupt exclude pipe0. + * Arguments : uint16_t status ; NRDYSTS Register Value + * : uint16_t intenb ; NRDYENB Register Value + * Return Value : none + *****************************************************************************/ +extern "C" { + void usbx_function_NRDYInterrupt( + uint16_t status, + uint16_t intenb, + USBHAL *object, + bool (USBHAL::*epCallback[])(void) + ) + { + volatile uint16_t dumy_sts; + + /************************************************************** + * Function Name: usbx_function_nrdy_int + * Description : Executes NRDY interrupt(USB_FUNCTION_PIPE1-9). + * : Checks NRDY interrupt cause by PID. When the cause if STALL, + * : regards the pipe state as STALL and ends the processing. + * : Then the cause is not STALL, increments the error count to + * : communicate again. When the error count is 3, determines + * : the pipe state as DEVDRV_USBF_PIPE_NORES and ends the processing. + * : This function is executed in the NRDY interrupt handler. + * : This function clears NRDY interrupt status. + * Arguments : uint16_t status ; NRDYSTS Register Value + * : uint16_t int_enb ; NRDYENB Register Value + * Return Value : none + *************************************************************/ + /* copied from usbx_function_intrn.c */ +#if 0 + uint16_t usefifo; +#endif + uint16_t pid; + uint16_t pipe; + uint16_t bitcheck; +#if 0 + uint16_t mbw; + uint32_t size; +#endif + uint16_t ep; + + bitcheck = (uint16_t)(status & intenb); + + USB20X.NRDYSTS = (uint16_t)~status; + + + if (RZA_IO_RegRead_16(&USB20X.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1) { + /* USB HOST */ + /* not support */ + + } else { + /* USB Function */ + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) { + if ((bitcheck&g_usbx_function_bit_set[pipe]) != g_usbx_function_bit_set[pipe]) { + continue; + } + + if (g_usbx_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_WAIT) { + continue; + } + +#if 0 + usbx_function_set_pid_nak(pipe); + + size = (uint32_t)g_usbx_function_data_count[pipe]; + mbw = usbx_function_get_mbw( + size, (uint32_t)g_usbx_function_data_pointer[pipe]); + + usefifo = (uint16_t)(g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE); + switch (usefifo) { + + case USB_FUNCTION_D0FIFO_USE: + usbx_function_set_curpipe( + pipe, USB_FUNCTION_D0USE, DEVDRV_USBF_NO, mbw); + USB20X.D0FIFOCTR = USB_FUNCTION_BITBCLR; + break; + + case USB_FUNCTION_D1FIFO_USE: + usbx_function_set_curpipe( + pipe, USB_FUNCTION_D1USE, DEVDRV_USBF_NO, mbw); + USB20X.D1FIFOCTR = USB_FUNCTION_BITBCLR; + break; + + default: + usbx_function_set_curpipe( + pipe, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_READ, mbw); + USB20X.CFIFOCTR = USB_FUNCTION_BITBCLR; + break; + } + + usbx_function_aclrm(pipe); + + usbx_function_enable_nrdy_int(pipe); + usbx_function_enable_brdy_int(pipe); + + usbx_function_set_pid_buf(pipe); +#endif + + pid = usbx_function_get_pid(pipe); + if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2)) { + g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; + } else { + usbx_function_set_pid_buf(pipe); + } + + ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; + ep <<= 1; + if (RZA_IO_RegRead_16( + &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) { + /* read */ + __NOP(); + } else { + /* write */ + __NOP(); + } + } + } + + /* Three dummy reads for clearing interrupt requests */ + dumy_sts = USB20X.NRDYSTS; + } +} + +/****************************************************************************** + * Function Name: usbx_function_BEMPInterruptPIPE0 + * Description : Executes BEMP interrupt for pipe0. + * Arguments : uint16_t status ; BEMPSTS Register Value + * : uint16_t intenb ; BEMPENB Register Value + * Return Value : none + *****************************************************************************/ +extern "C" { + void usbx_function_BEMPInterruptPIPE0( + uint16_t status, + uint16_t intenb, + USBHAL *object, + void (USBHAL::*EP0func)(void) + ) + { + volatile uint16_t dumy_sts; + + USB20X.BEMPSTS = + (uint16_t)~g_usbx_function_bit_set[USB_FUNCTION_PIPE0]; + RZA_IO_RegWrite_16( + &USB20X.CFIFOSEL, USB_FUNCTION_PIPE0, + USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE); + + /*usbx_function_write_buffer_c(USB_FUNCTION_PIPE0);*/ + (object->*EP0func)(); + + /* Three dummy reads for clearing interrupt requests */ + dumy_sts = USB20X.BEMPSTS; + } +} + + +/****************************************************************************** + * Function Name: usbx_function_BEMPInterrupt + * Description : Executes BEMP interrupt exclude pipe0. + * Arguments : uint16_t status ; BEMPSTS Register Value + * : uint16_t intenb ; BEMPENB Register Value + * Return Value : none + *****************************************************************************/ +extern "C" { + void usbx_function_BEMPInterrupt( + uint16_t status, + uint16_t intenb, + USBHAL *object, + bool (USBHAL::*epCallback[])(void) + ) + { + volatile uint16_t dumy_sts; + + /************************************************************** + * Function Name: usbx_function_bemp_int + * Description : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9). + * Arguments : uint16_t status ; BEMPSTS Register Value + * : uint16_t intenb ; BEMPENB Register Value + * Return Value : none + *************************************************************/ + /* copied from usbx_function_intrn.c */ + uint16_t pid; + uint16_t pipe; + uint16_t bitcheck; + uint16_t inbuf; + uint16_t ep; + + bitcheck = (uint16_t)(status & intenb); + + USB20X.BEMPSTS = (uint16_t)~status; + + for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++) { + if ((bitcheck&g_usbx_function_bit_set[pipe]) != g_usbx_function_bit_set[pipe]) { + continue; + } + + pid = usbx_function_get_pid(pipe); + + if ((pid == DEVDRV_USBF_PID_STALL) || + (pid == DEVDRV_USBF_PID_STALL2)) { + g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL; + + } else { + inbuf = usbx_function_get_inbuf(pipe); + + if (inbuf == 0) { + usbx_function_disable_bemp_int(pipe); + usbx_function_set_pid_nak(pipe); + g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE; + + switch (g_usbx_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) { + case USB_FUNCTION_D0FIFO_DMA: + /*now, DMA is not supported*/ + break; + + case USB_FUNCTION_D1FIFO_DMA: + /*now, DMA is not supported*/ + break; + + default: + ep = (g_usbx_function_pipecfg[pipe] & USB_PIPECFG_EPNUM) >> USB_PIPECFG_EPNUM_SHIFT; + ep <<= 1; + if (RZA_IO_RegRead_16( + &g_usbx_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0) { + /* read */ + __NOP(); + } else { + /* write */ + EPx_read_status = DEVDRV_USBF_PIPE_WAIT; + (object->*(epCallback[ep - 2 + 1])) (); + EPx_read_status = DEVDRV_USBF_PIPE_DONE; + } + } + } + } + } + + /* Three dummy reads for clearing interrupt requests */ + dumy_sts = USB20X.BEMPSTS; + } +} + +/****************************************************************************** + * Function Name: EP2PIPE + * Description : Converts from endpoint to pipe + * Arguments : number of endpoint + * Return Value : number of pipe + *****************************************************************************/ +/*EP2PIPE converter is for pipe1, pipe3 and pipe6 only.*/ +#define EP2PIPE(endpoint) ((uint32_t)usbx_function_EpToPipe(endpoint)) + + +/****************************************************************************** + * Function Name: usbx_function_save_request + * Description : Retains the USB request information in variables. + * Arguments : none + * Return Value : none + *****************************************************************************/ +#define usbx_function_save_request() \ + { \ + uint16_t *bufO = &setup_buffer[0]; \ + \ + USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVALID; \ + /*data[0] <= bmRequest, data[1] <= bmRequestType */ \ + *bufO++ = USB20X.USBREQ; \ + /*data[2] data[3] <= wValue*/ \ + *bufO++ = USB20X.USBVAL; \ + /*data[4] data[5] <= wIndex*/ \ + *bufO++ = USB20X.USBINDX; \ + /*data[6] data[6] <= wIndex*/ \ + *bufO++ = USB20X.USBLENG; \ + } + + +/*************************************************************************/ +/*************************************************************************/ +/*************************************************************************/ + +/*************************************************************************/ +/* constructor */ +USBHAL::USBHAL(void) +{ + /* ---- P4_1 : P4_1 (USB0_EN for GR-PEACH) ---- */ + //usbx_en = new DigitalOut(P4_1, 1); + + /* some constants */ + int_id = USBIX_IRQn; + int_level = ( 2 << 3 ); + clock_mode = USBFCLOCK_X1_48MHZ; +#if (USB_FUNCTION_HISPEED == 0) + mode = USB_FUNCTION_FULL_SPEED; +#else + mode = USB_FUNCTION_HIGH_SPEED; +#endif + EP0_read_status = DEVDRV_USBF_WRITEEND; + EPx_read_status = DEVDRV_USBF_PIPE_DONE; + + /* Disables interrupt for usb */ + GIC_DisableIRQ(int_id); + + /* Setup the end point */ + epCallback[ 0] = &USBHAL::EP1_OUT_callback; + epCallback[ 1] = &USBHAL::EP1_IN_callback; + epCallback[ 2] = &USBHAL::EP2_OUT_callback; + epCallback[ 3] = &USBHAL::EP2_IN_callback; + epCallback[ 4] = &USBHAL::EP3_OUT_callback; + epCallback[ 5] = &USBHAL::EP3_IN_callback; + epCallback[ 6] = &USBHAL::EP4_OUT_callback; + epCallback[ 7] = &USBHAL::EP4_IN_callback; + epCallback[ 8] = &USBHAL::EP5_OUT_callback; + epCallback[ 9] = &USBHAL::EP5_IN_callback; + epCallback[10] = &USBHAL::EP6_OUT_callback; + epCallback[11] = &USBHAL::EP6_IN_callback; + epCallback[12] = &USBHAL::EP7_OUT_callback; + epCallback[13] = &USBHAL::EP7_IN_callback; + epCallback[14] = &USBHAL::EP8_OUT_callback; + epCallback[15] = &USBHAL::EP8_IN_callback; + epCallback[16] = &USBHAL::EP9_OUT_callback; + epCallback[17] = &USBHAL::EP9_IN_callback; + epCallback[18] = &USBHAL::EP10_OUT_callback; + epCallback[19] = &USBHAL::EP10_IN_callback; + epCallback[20] = &USBHAL::EP11_OUT_callback; + epCallback[21] = &USBHAL::EP11_IN_callback; + epCallback[22] = &USBHAL::EP12_OUT_callback; + epCallback[23] = &USBHAL::EP12_IN_callback; + epCallback[24] = &USBHAL::EP13_OUT_callback; + epCallback[25] = &USBHAL::EP13_IN_callback; + epCallback[26] = &USBHAL::EP14_OUT_callback; + epCallback[27] = &USBHAL::EP14_IN_callback; + epCallback[28] = &USBHAL::EP15_OUT_callback; + epCallback[29] = &USBHAL::EP15_IN_callback; + + /* registers me */ + instance = this; + + /* Clear pipe table */ + usbx_function_clear_pipe_tbl(); + +/****************************************************************************** + * Function Name: usbx_api_function_init + * Description : Initializes the USB module in the USB function mode. + *****************************************************************************/ + /* The clock of USB0 modules is permitted */ +#if (USB_FUNCTION_CH == 0) + CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71); +#else + CPG.STBCR7 &= ~(CPG_STBCR7_MSTP71 | CPG_STBCR7_MSTP70); +#endif + volatile uint8_t dummy8; + dummy8 = CPG.STBCR7; + + { +/****************************************************************************** + * Function Name: usbx_function_setting_interrupt + * Description : Sets the USB module interrupt level. + *****************************************************************************/ +#if 0 /*DMA is not supported*/ + IRQn_Type d0fifo_dmaintid; + IRQn_Type d1fifo_dmaintid; +#endif + + InterruptHandlerRegister(int_id, &_usbisr); + GIC_SetPriority(int_id, int_level); + GIC_EnableIRQ(int_id); + +#if 0 /*DMA is not supported*/ + d0fifo_dmaintid = Userdef_USB_usbx_function_d0fifo_dmaintid(); + if (d0fifo_dmaintid != 0xFFFF) { + InterruptHandlerRegister(d0fifo_dmaintid, usbx_function_dma_interrupt_d0fifo); + GIC_SetPriority(d0fifo_dmaintid, int_level); + GIC_EnableIRQ(d0fifo_dmaintid); + } +#endif + +#if 0 /*DMA is not supported*/ + d1fifo_dmaintid = Userdef_USB_usbx_function_d1fifo_dmaintid(); + if (d1fifo_dmaintid != 0xFFFF) { + InterruptHandlerRegister(d1fifo_dmaintid, usbx_function_dma_interrupt_d1fifo); + GIC_SetPriority(d1fifo_dmaintid, int_level); + GIC_EnableIRQ(d1fifo_dmaintid); + } +#endif +/*****************************************************************************/ + } + + /* reset USB module with setting tranciever and HSE=1 */ + usbx_function_reset_module(clock_mode); + + /* clear variables */ + usbx_function_init_status(); + + /* select USB Function and Interrupt Enable */ + /* Detect USB Device to attach or detach */ + usbx_function_InitModule(mode); + + { + uint16_t buf; + buf = USB20X.INTENB0; + buf |= USB_INTENB0_SOFE; + USB20X.INTENB0 = buf; + } +} + +/*************************************************************************/ +USBHAL::~USBHAL(void) +{ + /* Disables interrupt for usb */ + GIC_DisableIRQ( int_id ); + /* Unregisters interrupt function and priority */ + InterruptHandlerRegister( int_id, (uint32_t)NULL ); + + //usbx_en = NULL; + instance = NULL; +} + +/*************************************************************************/ +void USBHAL::connect(void) +{ + /* Activates USB0_EN */ + //(*usbx_en) = 0; +} + + +/*************************************************************************/ +void USBHAL::disconnect(void) +{ + /* Deactivates USB0_EN */ + //(*usbx_en) = 1; +} + + +/*************************************************************************/ +void USBHAL::configureDevice(void) +{ + /*The pipes set up in USBHAL::realiseEndpoint*/ + /*usbx_function_clear_alt();*/ /* Alternate setting clear */ + /*usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);*/ +} + + +/*************************************************************************/ +void USBHAL::unconfigureDevice(void) +{ + /* The Interface would be managed by USBDevice */ + /*usbx_function_clear_alt();*/ /* Alternate setting clear */ + /*usbx_function_set_pid_buf(USB_FUNCTION_PIPE0);*/ +} + + +/*************************************************************************/ +void USBHAL::setAddress(uint8_t address) +{ + if (address <= 127) { + usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); /* OK */ + } else { + usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); /* Not Spec */ + } +} + + +/*************************************************************************/ +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t flags) +{ + const struct PIPECFGREC *cfg; + uint16_t pipe; + uint16_t buf; + + if ( (EP0OUT == endpoint) || (EP0IN == endpoint) ) { + return true; + } + + for (cfg = &def_pipecfg[0]; cfg->pipesel != 0; cfg++) { + if (cfg->endpoint == endpoint) { + break; + } + } + if (cfg->pipesel == 0) { + return false; + } + + pipe = ((cfg->pipesel & USB_PIPESEL_PIPESEL) >> USB_PIPESEL_PIPESEL_SHIFT); + + g_usbx_function_PipeTbl[ pipe ] = (uint16_t)(endpoint | ((cfg->pipesel & USB_FUNCTION_FIFO_USE) << 0)); + + /* There are maintenance routine of SHTNAK and BFRE bits + * in original sample program. This sample is not + * programmed. Do maintenance the "def_pipecfg" array if + * you want it. */ + + /* Interrupt Disable */ + buf = USB20X.BRDYENB; + buf &= (uint16_t)~g_usbx_function_bit_set[pipe]; + USB20X.BRDYENB = buf; + buf = USB20X.NRDYENB; + buf &= (uint16_t)~g_usbx_function_bit_set[pipe]; + USB20X.NRDYENB = buf; + buf = USB20X.BEMPENB; + buf &= (uint16_t)~g_usbx_function_bit_set[pipe]; + USB20X.BEMPENB = buf; + + usbx_function_set_pid_nak(pipe); + + /* CurrentPIPE Clear */ + if (RZA_IO_RegRead_16(&USB20X.CFIFOSEL, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE) == pipe) { + RZA_IO_RegWrite_16(&USB20X.CFIFOSEL, 0, USB_CFIFOSEL_CURPIPE_SHIFT, USB_CFIFOSEL_CURPIPE); + } + + if (RZA_IO_RegRead_16(&USB20X.D0FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) { + RZA_IO_RegWrite_16(&USB20X.D0FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE); + } + + if (RZA_IO_RegRead_16(&USB20X.D1FIFOSEL, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE) == pipe) { + RZA_IO_RegWrite_16(&USB20X.D1FIFOSEL, 0, USB_DnFIFOSEL_CURPIPE_SHIFT, USB_DnFIFOSEL_CURPIPE); + } + + /* PIPE Configuration */ + USB20X.PIPESEL = pipe; + USB20X.PIPECFG = cfg->pipecfg; + USB20X.PIPEBUF = cfg->pipebuf; + USB20X.PIPEMAXP = cfg->pipemaxp; + USB20X.PIPEPERI = cfg->pipeperi; + + g_usbx_function_pipecfg[pipe] = cfg->pipecfg; + g_usbx_function_pipebuf[pipe] = cfg->pipebuf; + g_usbx_function_pipemaxp[pipe] = cfg->pipemaxp; + g_usbx_function_pipeperi[pipe] = cfg->pipeperi; + + /* Buffer Clear */ + usbx_function_set_sqclr(pipe); + usbx_function_aclrm(pipe); + + /* init Global */ + g_usbx_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE; + g_usbx_function_PipeDataSize[pipe] = 0; + + return true; +} + + +/*************************************************************************/ +// read setup packet +void USBHAL::EP0setup(uint8_t *buffer) +{ + memcpy(buffer, setup_buffer, MAX_PACKET_SIZE_EP0); +} + + +/*************************************************************************/ +void USBHAL::EP0readStage(void) +{ + // No implements +} + + +/*************************************************************************/ +void USBHAL::EP0read(void) +{ + uint8_t *buffer; + uint32_t size; + + /* remain of last writing */ + while (EP0_read_status != DEVDRV_USBF_WRITEEND) { + static uint8_t bbb[2] = { 255, 255 }; + EP0write(&bbb[0], 0); + } + + buffer = (uint8_t*)(&setup_buffer[4]); + size = (MAX_PACKET_SIZE_EP0 / 2) - 8; + usbx_api_function_CtrlWriteStart(size, buffer); +} + + +/*************************************************************************/ +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) +{ + memcpy(buffer, (uint8_t*)(&setup_buffer[4]), g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0]); + + return g_usbx_function_PipeDataSize[USB_FUNCTION_PIPE0]; +} + + +/*************************************************************************/ +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) +{ + /* zero byte writing */ + if ( (size == 0) && (EP0_read_status == DEVDRV_USBF_WRITEEND) ) { + return; + } + + if (EP0_read_status == DEVDRV_USBF_WRITEEND) { + /*1st block*/ + EP0_read_status = usbx_api_function_CtrlReadStart(size, buffer); + } else { + /* waits the last transmission */ + /*other blocks*/ + g_usbx_function_data_count[ USB_FUNCTION_PIPE0 ] = size; + g_usbx_function_data_pointer [ USB_FUNCTION_PIPE0 ] = buffer; + EP0_read_status = usbx_function_write_buffer_c(USB_FUNCTION_PIPE0); + } + /*max size may be deblocking outside*/ + if (size == MAX_PACKET_SIZE_EP0) { + EP0_read_status = DEVDRV_USBF_WRITING; + } +} + + +/*************************************************************************/ +#if 0 // No implements +void USBHAL::EP0getWriteResult(void) +{ +} +#endif + +/*************************************************************************/ +void USBHAL::EP0stall(void) +{ + stallEndpoint( 0 ); +} + + +/*************************************************************************/ +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t max_size) +{ + uint32_t pipe = EP2PIPE(endpoint); + uint32_t pipe_size; + uint16_t pipe_status; + EP_STATUS status = EP_COMPLETED; + + pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); + + switch (pipe_status) { + case DEVDRV_USBF_PIPE_IDLE: + case DEVDRV_USBF_PIPE_WAIT: + usbx_api_function_set_pid_nak(pipe); + usbx_api_function_clear_pipe_status(pipe); + + usbx_api_function_start_receive_transfer(pipe, max_size, recv_buffer); + break; + + default: + status = EP_PENDING; + break; + } + + return status; +} + + +/*************************************************************************/ +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t *buffer, uint32_t *bytes_read ) +{ + uint32_t pipe = EP2PIPE(endpoint); + uint16_t pipe_status; + uint16_t err; + EP_STATUS status = EP_PENDING; + + + if (EPx_read_status != DEVDRV_USBF_PIPE_WAIT) { + return status; + } + + pipe_status = usbx_api_function_check_pipe_status(pipe, bytes_read); + switch (pipe_status) { + case DEVDRV_USBF_PIPE_IDLE: + return EP_COMPLETED; + + case DEVDRV_USBF_PIPE_DONE: + return EP_COMPLETED; + + case DEVDRV_USBF_PIPE_WAIT: + break; + + default: + return status; + } + + /* sets the output buffer and size */ + g_usbx_function_data_pointer[pipe] = buffer; + + /* receives data from pipe */ + err = usbx_function_read_buffer(pipe); + recv_error = err; + switch (err) { + case USB_FUNCTION_READEND: + case USB_FUNCTION_READSHRT: + case USB_FUNCTION_READOVER: + *bytes_read = g_usbx_function_PipeDataSize[pipe]; + break; + + case USB_FUNCTION_READING: + case DEVDRV_USBF_FIFOERROR: + break; + } + + pipe_status = usbx_api_function_check_pipe_status(pipe, bytes_read); + switch (pipe_status) { + case DEVDRV_USBF_PIPE_DONE: + status = EP_COMPLETED; + break; + + case DEVDRV_USBF_PIPE_IDLE: + case DEVDRV_USBF_PIPE_NORES: + case DEVDRV_USBF_PIPE_STALL: + case DEVDRV_USBF_FIFOERROR: + default: + break; + } + + return status; +} + + +/*************************************************************************/ +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) +{ + uint32_t pipe = EP2PIPE(endpoint); + uint32_t pipe_size; + uint16_t pipe_status; + uint16_t err; + uint16_t count; + EP_STATUS status = EP_PENDING; + + pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); + + /* waits the last transmission */ + count = 30000; + while ((pipe_status == DEVDRV_USBF_PIPE_WAIT) || (pipe_status == DEVDRV_USBF_PIPE_DONE)) { + pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); + if( --count == 0 ) { + pipe_status = DEVDRV_USBF_PIPE_STALL; + break; + } + } + + switch (pipe_status) { + case DEVDRV_USBF_PIPE_IDLE: + err = usbx_api_function_start_send_transfer(pipe, size, data); + + switch (err) { + /* finish to write */ + case DEVDRV_USBF_WRITEEND: + /* finish to write, but data is short */ + case DEVDRV_USBF_WRITESHRT: + /* continue to write */ + case DEVDRV_USBF_WRITING: + /* use DMA */ + case DEVDRV_USBF_WRITEDMA: + /* error */ + case DEVDRV_USBF_FIFOERROR: + status = EP_PENDING; + break; + } + break; + + case DEVDRV_USBF_PIPE_WAIT: + case DEVDRV_USBF_PIPE_DONE: + status = EP_PENDING; + break; + + case DEVDRV_USBF_PIPE_NORES: + case DEVDRV_USBF_PIPE_STALL: + default: + status = EP_STALLED; + break; + } + + return status; +} + + +/*************************************************************************/ +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) +{ + uint32_t pipe = EP2PIPE(endpoint); + uint32_t pipe_size; + uint16_t pipe_status; + EP_STATUS status = EP_PENDING; + + pipe_status = usbx_api_function_check_pipe_status(pipe, &pipe_size); + + switch (pipe_status) { + case DEVDRV_USBF_PIPE_IDLE: + status = EP_COMPLETED; + break; + + case DEVDRV_USBF_PIPE_WAIT: + status = EP_PENDING; + break; + + case DEVDRV_USBF_PIPE_DONE: + usbx_function_stop_transfer(pipe); + status = EP_COMPLETED; + break; + + case DEVDRV_USBF_PIPE_NORES: + status = EP_STALLED; + break; + + case DEVDRV_USBF_PIPE_STALL: + status = EP_STALLED; + break; + + default: + status = EP_PENDING; + } + + return status; +} + + +/*************************************************************************/ +void USBHAL::stallEndpoint(uint8_t endpoint) +{ + uint32_t pipe = EP2PIPE(endpoint); + + usbx_function_clear_pid_stall(pipe); +} + + +/*************************************************************************/ +void USBHAL::unstallEndpoint(uint8_t endpoint) +{ + uint32_t pipe = EP2PIPE(endpoint); + + usbx_function_set_pid_stall( pipe ); +} + + +/*************************************************************************/ +bool USBHAL::getEndpointStallState(uint8_t endpoint) +{ + // No implemens + return false; +} + + +/*************************************************************************/ +#if 0 // No implements +void USBHAL::remoteWakeup(void) +{ +} +#endif + +/*************************************************************************/ +void USBHAL::_usbisr(void) +{ + instance->usbisr(); +} + + +/*************************************************************************/ +void USBHAL::usbisr(void) +{ + uint16_t int_sts0; + uint16_t int_sts1; + uint16_t int_sts2; + uint16_t int_sts3; + uint16_t int_enb0; + uint16_t int_enb2; + uint16_t int_enb3; + uint16_t int_enb4; + volatile uint16_t dumy_sts; + + + int_sts0 = USB20X.INTSTS0; + + if (!(int_sts0 & ( + USB_FUNCTION_BITVBINT | + USB_FUNCTION_BITRESM | + USB_FUNCTION_BITSOFR | + USB_FUNCTION_BITDVST | + USB_FUNCTION_BITCTRT | + USB_FUNCTION_BITBEMP | + USB_FUNCTION_BITNRDY | + USB_FUNCTION_BITBRDY ))) { + return; + } + + int_sts1 = USB20X.BRDYSTS; + int_sts2 = USB20X.NRDYSTS; + int_sts3 = USB20X.BEMPSTS; + int_enb0 = USB20X.INTENB0; + int_enb2 = USB20X.BRDYENB; + int_enb3 = USB20X.NRDYENB; + int_enb4 = USB20X.BEMPENB; + + if ((int_sts0 & USB_FUNCTION_BITRESM) && + (int_enb0 & USB_FUNCTION_BITRSME)) { + USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITRESM; + RZA_IO_RegWrite_16(&USB20X.INTENB0, 0, USB_INTENB0_RSME_SHIFT, USB_INTENB0_RSME); + /*usbx_function_USB_FUNCTION_Resume();*/ + suspendStateChanged(1); + } else if ( + (int_sts0 & USB_FUNCTION_BITVBINT) && + (int_enb0 & USB_FUNCTION_BITVBSE)) { + USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITVBINT; + + if (usbx_function_CheckVBUStaus() == DEVDRV_USBF_ON) { + usbx_function_USB_FUNCTION_Attach(); + } else { + usbx_function_USB_FUNCTION_Detach(); + } + } else if ( + (int_sts0 & USB_FUNCTION_BITSOFR) && + (int_enb0 & USB_FUNCTION_BITSOFE)) { + USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITSOFR; + SOF((USB20X.FRMNUM & USB_FRMNUM_FRNM) >> USB_FRMNUM_FRNM_SHIFT); + } else if ( + (int_sts0 & USB_FUNCTION_BITDVST) && + (int_enb0 & USB_FUNCTION_BITDVSE)) { + USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITDVST; + switch (int_sts0 & USB_FUNCTION_BITDVSQ) { + case USB_FUNCTION_DS_POWR: + break; + + case USB_FUNCTION_DS_DFLT: + /***************************************************************************** + * Function Name: usbx_function_USB_FUNCTION_BusReset + * Description : This function is executed when the USB device is transitioned + * : to POWERD_STATE. Sets the device descriptor according to the + * : connection speed determined by the USB reset hand shake. + * Arguments : none + * Return Value : none + *****************************************************************************/ + usbx_function_init_status(); /* memory clear */ + +#if 0 + /* You would program those steps in USBCallback_busReset + * if the system need the comment out steps. + */ + + if (usbx_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED) { + /* Device Descriptor reset */ + usbx_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED); + } else { + /* Device Descriptor reset */ + usbx_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED); + } +#endif + /* Default Control PIPE reset */ + /***************************************************************************** + * Function Name: usbx_function_ResetDCP + * Description : Initializes the default control pipe(DCP). + * Outline : Reset default control pipe + * Arguments : none + * Return Value : none + *****************************************************************************/ + USB20X.DCPCFG = 0; + USB20X.DCPMAXP = 64; /*TODO: This value is copied from sample*/ + + USB20X.CFIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + USB20X.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + USB20X.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE); + + busReset(); + break; + + case USB_FUNCTION_DS_ADDS: + break; + + case USB_FUNCTION_DS_CNFG: + break; + + case USB_FUNCTION_DS_SPD_POWR: + case USB_FUNCTION_DS_SPD_DFLT: + case USB_FUNCTION_DS_SPD_ADDR: + case USB_FUNCTION_DS_SPD_CNFG: + suspendStateChanged(0); + /*usbx_function_USB_FUNCTION_Suspend();*/ + break; + + default: + break; + } + } else if ( + (int_sts0 & USB_FUNCTION_BITBEMP) && + (int_enb0 & USB_FUNCTION_BITBEMP) && + ((int_sts3 & int_enb4) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) { + /* ==== BEMP PIPE0 ==== */ + usbx_function_BEMPInterruptPIPE0(int_sts3, int_enb4, this, &USBHAL::EP0in); + } else if ( + (int_sts0 & USB_FUNCTION_BITBRDY) && + (int_enb0 & USB_FUNCTION_BITBRDY) && + ((int_sts1 & int_enb2) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) { + /* ==== BRDY PIPE0 ==== */ + usbx_function_BRDYInterruptPIPE0(int_sts1, int_enb2, this, &USBHAL::EP0out); + } else if ( + (int_sts0 & USB_FUNCTION_BITNRDY) && + (int_enb0 & USB_FUNCTION_BITNRDY) && + ((int_sts2 & int_enb3) & g_usbx_function_bit_set[USB_FUNCTION_PIPE0])) { + /* ==== NRDY PIPE0 ==== */ + usbx_function_NRDYInterruptPIPE0(int_sts2, int_enb3, this, NULL); + } else if ( + (int_sts0 & USB_FUNCTION_BITCTRT) && (int_enb0 & USB_FUNCTION_BITCTRE)) { + int_sts0 = USB20X.INTSTS0; + USB20X.INTSTS0 = (uint16_t)~USB_FUNCTION_BITCTRT; + + if (((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_RDDS) || + ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRDS) || + ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRND)) { + + /* remake EP0 into buffer */ + usbx_function_save_request(); + if ((USB20X.INTSTS0 & USB_FUNCTION_BITVALID) && ( + ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_RDDS) || + ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRDS) || + ((int_sts0 & USB_FUNCTION_BITCTSQ) == USB_FUNCTION_CS_WRND))) { + /* New SETUP token received */ + /* Three dummy reads for cleearing interrupt requests */ + dumy_sts = USB20X.INTSTS0; + dumy_sts = USB20X.INTSTS0; + dumy_sts = USB20X.INTSTS0; + return; + } + } + + switch (int_sts0 & USB_FUNCTION_BITCTSQ) { + case USB_FUNCTION_CS_IDST: + if (g_usbx_function_TestModeFlag == DEVDRV_USBF_YES) { + /* ==== Test Mode ==== */ + usbx_function_USB_FUNCTION_TestMode(); + } + /* Needs not procedure in this state */ + break; + + case USB_FUNCTION_CS_RDDS: + /* Reads a setup packet */ + EP0setupCallback(); + break; + + case USB_FUNCTION_CS_WRDS: + /* Original code was the SetDescriptor was called */ + EP0setupCallback(); + break; + + case USB_FUNCTION_CS_WRND: + EP0setupCallback(); + + /*The EP0setupCallback should finish in successful */ + usbx_function_set_pid_buf(USB_FUNCTION_PIPE0); + + RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL); + break; + + case USB_FUNCTION_CS_RDSS: + RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL); + break; + + case USB_FUNCTION_CS_WRSS: + RZA_IO_RegWrite_16(&USB20X.DCPCTR, 1, USB_DCPCTR_CCPL_SHIFT, USB_DCPCTR_CCPL); + break; + + case USB_FUNCTION_CS_SQER: + usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); + break; + + default: + usbx_function_set_pid_stall(USB_FUNCTION_PIPE0); + break; + } + } else if ( + (int_sts0 & USB_FUNCTION_BITBEMP) && + (int_enb0 & USB_FUNCTION_BITBEMP) && + (int_sts3 & int_enb4) ) { + /* ==== BEMP PIPEx ==== */ + usbx_function_BEMPInterrupt(int_sts3, int_enb4, this, epCallback); + } else if ( + (int_sts0 & USB_FUNCTION_BITBRDY) && + (int_enb0 & USB_FUNCTION_BITBRDY) && + (int_sts1 & int_enb2) ) { + /* ==== BRDY PIPEx ==== */ + usbx_function_BRDYInterrupt(int_sts1, int_enb2, this, epCallback); + } else if ( + (int_sts0 & USB_FUNCTION_BITNRDY) && + (int_enb0 & USB_FUNCTION_BITNRDY) && + (int_sts2 & int_enb3)) { + /* ==== NRDY PIPEx ==== */ + usbx_function_NRDYInterrupt(int_sts2, int_enb3, this, epCallback); + } else { + /* Do Nothing */ + } + + /* Three dummy reads for cleearing interrupt requests */ + dumy_sts = USB20X.INTSTS0; + dumy_sts = USB20X.INTSTS1; +} + +/*************************************************************************/ +#endif +/*************************************************************************/ +/*EOF*/ diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_STM32F4.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_STM32F4.cpp new file mode 100644 index 000000000..8faac6170 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_STM32F4.cpp @@ -0,0 +1,410 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#if defined(TARGET_STM32F4) + +#include "USBHAL.h" +#include "USBRegs_STM32.h" +#include "pinmap.h" + +USBHAL * USBHAL::instance; + +static volatile int epComplete = 0; + +static uint32_t bufferEnd = 0; +static const uint32_t rxFifoSize = 512; +static uint32_t rxFifoCount = 0; + +static uint32_t setupBuffer[MAX_PACKET_SIZE_EP0 >> 2]; + +uint32_t USBHAL::endpointReadcore(uint8_t endpoint, uint8_t *buffer) { + return 0; +} + +USBHAL::USBHAL(void) { + NVIC_DisableIRQ(OTG_FS_IRQn); + epCallback[0] = &USBHAL::EP1_OUT_callback; + epCallback[1] = &USBHAL::EP1_IN_callback; + epCallback[2] = &USBHAL::EP2_OUT_callback; + epCallback[3] = &USBHAL::EP2_IN_callback; + epCallback[4] = &USBHAL::EP3_OUT_callback; + epCallback[5] = &USBHAL::EP3_IN_callback; + + // Enable power and clocking + RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; + +#if defined(TARGET_STM32F407VG) || defined(TARGET_STM32F401RE) || defined(TARGET_STM32F411RE) + pin_function(PA_8, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); + pin_function(PA_9, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLDOWN, GPIO_AF10_OTG_FS)); + pin_function(PA_10, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_PULLUP, GPIO_AF10_OTG_FS)); + pin_function(PA_11, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); + pin_function(PA_12, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); +#else + pin_function(PA_8, STM_PIN_DATA(2, 10)); + pin_function(PA_9, STM_PIN_DATA(0, 0)); + pin_function(PA_10, STM_PIN_DATA(2, 10)); + pin_function(PA_11, STM_PIN_DATA(2, 10)); + pin_function(PA_12, STM_PIN_DATA(2, 10)); + + // Set ID pin to open drain with pull-up resistor + pin_mode(PA_10, OpenDrain); + GPIOA->PUPDR &= ~(0x3 << 20); + GPIOA->PUPDR |= 1 << 20; + + // Set VBUS pin to open drain + pin_mode(PA_9, OpenDrain); +#endif + + RCC->AHB2ENR |= RCC_AHB2ENR_OTGFSEN; + + // Enable interrupts + OTG_FS->GREGS.GAHBCFG |= (1 << 0); + + // Turnaround time to maximum value - too small causes packet loss + OTG_FS->GREGS.GUSBCFG |= (0xF << 10); + + // Unmask global interrupts + OTG_FS->GREGS.GINTMSK |= (1 << 3) | // SOF + (1 << 4) | // RX FIFO not empty + (1 << 12); // USB reset + + OTG_FS->DREGS.DCFG |= (0x3 << 0) | // Full speed + (1 << 2); // Non-zero-length status OUT handshake + + OTG_FS->GREGS.GCCFG |= (1 << 19) | // Enable VBUS sensing + (1 << 16); // Power Up + + instance = this; + NVIC_SetVector(OTG_FS_IRQn, (uint32_t)&_usbisr); + NVIC_SetPriority(OTG_FS_IRQn, 1); +} + +USBHAL::~USBHAL(void) { +} + +void USBHAL::connect(void) { + NVIC_EnableIRQ(OTG_FS_IRQn); +} + +void USBHAL::disconnect(void) { + NVIC_DisableIRQ(OTG_FS_IRQn); +} + +void USBHAL::configureDevice(void) { + // Not needed +} + +void USBHAL::unconfigureDevice(void) { + // Not needed +} + +void USBHAL::setAddress(uint8_t address) { + OTG_FS->DREGS.DCFG |= (address << 4); + EP0write(0, 0); +} + +bool USBHAL::realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, + uint32_t flags) { + uint32_t epIndex = endpoint >> 1; + + uint32_t type; + switch (endpoint) { + case EP0IN: + case EP0OUT: + type = 0; + break; + case EPISO_IN: + case EPISO_OUT: + type = 1; + case EPBULK_IN: + case EPBULK_OUT: + type = 2; + break; + case EPINT_IN: + case EPINT_OUT: + type = 3; + break; + } + + // Generic in or out EP controls + uint32_t control = (maxPacket << 0) | // Packet size + (1 << 15) | // Active endpoint + (type << 18); // Endpoint type + + if (endpoint & 0x1) { // In Endpoint + // Set up the Tx FIFO + if (endpoint == EP0IN) { + OTG_FS->GREGS.DIEPTXF0_HNPTXFSIZ = ((maxPacket >> 2) << 16) | + (bufferEnd << 0); + } + else { + OTG_FS->GREGS.DIEPTXF[epIndex - 1] = ((maxPacket >> 2) << 16) | + (bufferEnd << 0); + } + bufferEnd += maxPacket >> 2; + + // Set the In EP specific control settings + if (endpoint != EP0IN) { + control |= (1 << 28); // SD0PID + } + + control |= (epIndex << 22) | // TxFIFO index + (1 << 27); // SNAK + OTG_FS->INEP_REGS[epIndex].DIEPCTL = control; + + // Unmask the interrupt + OTG_FS->DREGS.DAINTMSK |= (1 << epIndex); + } + else { // Out endpoint + // Set the out EP specific control settings + control |= (1 << 26); // CNAK + OTG_FS->OUTEP_REGS[epIndex].DOEPCTL = control; + + // Unmask the interrupt + OTG_FS->DREGS.DAINTMSK |= (1 << (epIndex + 16)); + } + return true; +} + +// read setup packet +void USBHAL::EP0setup(uint8_t *buffer) { + memcpy(buffer, setupBuffer, MAX_PACKET_SIZE_EP0); +} + +void USBHAL::EP0readStage(void) { +} + +void USBHAL::EP0read(void) { +} + +uint32_t USBHAL::EP0getReadResult(uint8_t *buffer) { + uint32_t* buffer32 = (uint32_t *) buffer; + uint32_t length = rxFifoCount; + for (uint32_t i = 0; i < length; i += 4) { + buffer32[i >> 2] = OTG_FS->FIFO[0][0]; + } + + rxFifoCount = 0; + return length; +} + +void USBHAL::EP0write(uint8_t *buffer, uint32_t size) { + endpointWrite(0, buffer, size); +} + +void USBHAL::EP0getWriteResult(void) { +} + +void USBHAL::EP0stall(void) { + // If we stall the out endpoint here then we have problems transferring + // and setup requests after the (stalled) get device qualifier requests. + // TODO: Find out if this is correct behavior, or whether we are doing + // something else wrong + stallEndpoint(EP0IN); +// stallEndpoint(EP0OUT); +} + +EP_STATUS USBHAL::endpointRead(uint8_t endpoint, uint32_t maximumSize) { + uint32_t epIndex = endpoint >> 1; + uint32_t size = (1 << 19) | // 1 packet + (maximumSize << 0); // Packet size +// if (endpoint == EP0OUT) { + size |= (1 << 29); // 1 setup packet +// } + OTG_FS->OUTEP_REGS[epIndex].DOEPTSIZ = size; + OTG_FS->OUTEP_REGS[epIndex].DOEPCTL |= (1 << 31) | // Enable endpoint + (1 << 26); // Clear NAK + + epComplete &= ~(1 << endpoint); + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointReadResult(uint8_t endpoint, uint8_t * buffer, uint32_t *bytesRead) { + if (!(epComplete & (1 << endpoint))) { + return EP_PENDING; + } + + uint32_t* buffer32 = (uint32_t *) buffer; + uint32_t length = rxFifoCount; + for (uint32_t i = 0; i < length; i += 4) { + buffer32[i >> 2] = OTG_FS->FIFO[endpoint >> 1][0]; + } + rxFifoCount = 0; + *bytesRead = length; + return EP_COMPLETED; +} + +EP_STATUS USBHAL::endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size) { + uint32_t epIndex = endpoint >> 1; + OTG_FS->INEP_REGS[epIndex].DIEPTSIZ = (1 << 19) | // 1 packet + (size << 0); // Size of packet + OTG_FS->INEP_REGS[epIndex].DIEPCTL |= (1 << 31) | // Enable endpoint + (1 << 26); // CNAK + OTG_FS->DREGS.DIEPEMPMSK = (1 << epIndex); + + while ((OTG_FS->INEP_REGS[epIndex].DTXFSTS & 0XFFFF) < ((size + 3) >> 2)); + + for (uint32_t i=0; i<(size + 3) >> 2; i++, data+=4) { + OTG_FS->FIFO[epIndex][0] = *(uint32_t *)data; + } + + epComplete &= ~(1 << endpoint); + + return EP_PENDING; +} + +EP_STATUS USBHAL::endpointWriteResult(uint8_t endpoint) { + if (epComplete & (1 << endpoint)) { + epComplete &= ~(1 << endpoint); + return EP_COMPLETED; + } + + return EP_PENDING; +} + +void USBHAL::stallEndpoint(uint8_t endpoint) { + if (endpoint & 0x1) { // In EP + OTG_FS->INEP_REGS[endpoint >> 1].DIEPCTL |= (1 << 30) | // Disable + (1 << 21); // Stall + } + else { // Out EP + OTG_FS->DREGS.DCTL |= (1 << 9); // Set global out NAK + OTG_FS->OUTEP_REGS[endpoint >> 1].DOEPCTL |= (1 << 30) | // Disable + (1 << 21); // Stall + } +} + +void USBHAL::unstallEndpoint(uint8_t endpoint) { + +} + +bool USBHAL::getEndpointStallState(uint8_t endpoint) { + return false; +} + +void USBHAL::remoteWakeup(void) { +} + + +void USBHAL::_usbisr(void) { + instance->usbisr(); +} + + +void USBHAL::usbisr(void) { + if (OTG_FS->GREGS.GINTSTS & (1 << 12)) { // USB Reset + // Set SNAK bits + OTG_FS->OUTEP_REGS[0].DOEPCTL |= (1 << 27); + OTG_FS->OUTEP_REGS[1].DOEPCTL |= (1 << 27); + OTG_FS->OUTEP_REGS[2].DOEPCTL |= (1 << 27); + OTG_FS->OUTEP_REGS[3].DOEPCTL |= (1 << 27); + + OTG_FS->DREGS.DIEPMSK = (1 << 0); + + bufferEnd = 0; + + // Set the receive FIFO size + OTG_FS->GREGS.GRXFSIZ = rxFifoSize >> 2; + bufferEnd += rxFifoSize >> 2; + + // Create the endpoints, and wait for setup packets on out EP0 + realiseEndpoint(EP0IN, MAX_PACKET_SIZE_EP0, 0); + realiseEndpoint(EP0OUT, MAX_PACKET_SIZE_EP0, 0); + endpointRead(EP0OUT, MAX_PACKET_SIZE_EP0); + + OTG_FS->GREGS.GINTSTS = (1 << 12); + } + + if (OTG_FS->GREGS.GINTSTS & (1 << 4)) { // RX FIFO not empty + uint32_t status = OTG_FS->GREGS.GRXSTSP; + + uint32_t endpoint = (status & 0xF) << 1; + uint32_t length = (status >> 4) & 0x7FF; + uint32_t type = (status >> 17) & 0xF; + + rxFifoCount = length; + + if (type == 0x6) { + // Setup packet + for (uint32_t i=0; i<length; i+=4) { + setupBuffer[i >> 2] = OTG_FS->FIFO[0][i >> 2]; + } + rxFifoCount = 0; + } + + if (type == 0x4) { + // Setup complete + EP0setupCallback(); + endpointRead(EP0OUT, MAX_PACKET_SIZE_EP0); + } + + if (type == 0x2) { + // Out packet + if (endpoint == EP0OUT) { + EP0out(); + } + else { + epComplete |= (1 << endpoint); + if ((instance->*(epCallback[endpoint - 2]))()) { + epComplete &= (1 << endpoint); + } + } + } + + for (uint32_t i=0; i<rxFifoCount; i+=4) { + (void) OTG_FS->FIFO[0][0]; + } + OTG_FS->GREGS.GINTSTS = (1 << 4); + } + + if (OTG_FS->GREGS.GINTSTS & (1 << 18)) { // In endpoint interrupt + // Loop through the in endpoints + for (uint32_t i=0; i<4; i++) { + if (OTG_FS->DREGS.DAINT & (1 << i)) { // Interrupt is on endpoint + + if (OTG_FS->INEP_REGS[i].DIEPINT & (1 << 7)) {// Tx FIFO empty + // If the Tx FIFO is empty on EP0 we need to send a further + // packet, so call EP0in() + if (i == 0) { + EP0in(); + } + // Clear the interrupt + OTG_FS->INEP_REGS[i].DIEPINT = (1 << 7); + // Stop firing Tx empty interrupts + // Will get turned on again if another write is called + OTG_FS->DREGS.DIEPEMPMSK &= ~(1 << i); + } + + // If the transfer is complete + if (OTG_FS->INEP_REGS[i].DIEPINT & (1 << 0)) { // Tx Complete + epComplete |= (1 << (1 + (i << 1))); + OTG_FS->INEP_REGS[i].DIEPINT = (1 << 0); + } + } + } + OTG_FS->GREGS.GINTSTS = (1 << 18); + } + + if (OTG_FS->GREGS.GINTSTS & (1 << 3)) { // Start of frame + SOF((OTG_FS->GREGS.GRXSTSR >> 17) & 0xF); + OTG_FS->GREGS.GINTSTS = (1 << 3); + } +} + + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBRegs_STM32.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBRegs_STM32.h new file mode 100644 index 000000000..3e11a49c1 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBRegs_STM32.h @@ -0,0 +1,149 @@ +/** + ****************************************************************************** + * @file usb_regs.h + * @author MCD Application Team + * @version V2.1.0 + * @date 19-March-2012 + * @brief hardware registers + ****************************************************************************** + * @attention + * + * <h2><center>© COPYRIGHT 2012 STMicroelectronics</center></h2> + * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +#ifndef __USB_OTG_REGS_H__ +#define __USB_OTG_REGS_H__ + +typedef struct //000h +{ + __IO uint32_t GOTGCTL; /* USB_OTG Control and Status Register 000h*/ + __IO uint32_t GOTGINT; /* USB_OTG Interrupt Register 004h*/ + __IO uint32_t GAHBCFG; /* Core AHB Configuration Register 008h*/ + __IO uint32_t GUSBCFG; /* Core USB Configuration Register 00Ch*/ + __IO uint32_t GRSTCTL; /* Core Reset Register 010h*/ + __IO uint32_t GINTSTS; /* Core Interrupt Register 014h*/ + __IO uint32_t GINTMSK; /* Core Interrupt Mask Register 018h*/ + __IO uint32_t GRXSTSR; /* Receive Sts Q Read Register 01Ch*/ + __IO uint32_t GRXSTSP; /* Receive Sts Q Read & POP Register 020h*/ + __IO uint32_t GRXFSIZ; /* Receive FIFO Size Register 024h*/ + __IO uint32_t DIEPTXF0_HNPTXFSIZ; /* EP0 / Non Periodic Tx FIFO Size Register 028h*/ + __IO uint32_t HNPTXSTS; /* Non Periodic Tx FIFO/Queue Sts reg 02Ch*/ + uint32_t Reserved30[2]; /* Reserved 030h*/ + __IO uint32_t GCCFG; /* General Purpose IO Register 038h*/ + __IO uint32_t CID; /* User ID Register 03Ch*/ + uint32_t Reserved40[48]; /* Reserved 040h-0FFh*/ + __IO uint32_t HPTXFSIZ; /* Host Periodic Tx FIFO Size Reg 100h*/ + __IO uint32_t DIEPTXF[3];/* dev Periodic Transmit FIFO */ +} +USB_OTG_GREGS; + +typedef struct // 800h +{ + __IO uint32_t DCFG; /* dev Configuration Register 800h*/ + __IO uint32_t DCTL; /* dev Control Register 804h*/ + __IO uint32_t DSTS; /* dev Status Register (RO) 808h*/ + uint32_t Reserved0C; /* Reserved 80Ch*/ + __IO uint32_t DIEPMSK; /* dev IN Endpoint Mask 810h*/ + __IO uint32_t DOEPMSK; /* dev OUT Endpoint Mask 814h*/ + __IO uint32_t DAINT; /* dev All Endpoints Itr Reg 818h*/ + __IO uint32_t DAINTMSK; /* dev All Endpoints Itr Mask 81Ch*/ + uint32_t Reserved20; /* Reserved 820h*/ + uint32_t Reserved9; /* Reserved 824h*/ + __IO uint32_t DVBUSDIS; /* dev VBUS discharge Register 828h*/ + __IO uint32_t DVBUSPULSE; /* dev VBUS Pulse Register 82Ch*/ + __IO uint32_t DTHRCTL; /* dev thr 830h*/ + __IO uint32_t DIEPEMPMSK; /* dev empty msk 834h*/ +} +USB_OTG_DREGS; + +typedef struct +{ + __IO uint32_t DIEPCTL; /* dev IN Endpoint Control Reg 900h + (ep_num * 20h) + 00h*/ + uint32_t Reserved04; /* Reserved 900h + (ep_num * 20h) + 04h*/ + __IO uint32_t DIEPINT; /* dev IN Endpoint Itr Reg 900h + (ep_num * 20h) + 08h*/ + uint32_t Reserved0C; /* Reserved 900h + (ep_num * 20h) + 0Ch*/ + __IO uint32_t DIEPTSIZ; /* IN Endpoint Txfer Size 900h + (ep_num * 20h) + 10h*/ + uint32_t Reserved14; + __IO uint32_t DTXFSTS;/*IN Endpoint Tx FIFO Status Reg 900h + (ep_num * 20h) + 18h*/ + uint32_t Reserved1C; /* Reserved 900h+(ep_num*20h)+1Ch-900h+ (ep_num * 20h) + 1Ch*/ +} +USB_OTG_INEPREGS; + +typedef struct +{ + __IO uint32_t DOEPCTL; /* dev OUT Endpoint Control Reg B00h + (ep_num * 20h) + 00h*/ + uint32_t Reserved04; /* Reserved B00h + (ep_num * 20h) + 04h*/ + __IO uint32_t DOEPINT; /* dev OUT Endpoint Itr Reg B00h + (ep_num * 20h) + 08h*/ + uint32_t Reserved0C; /* Reserved B00h + (ep_num * 20h) + 0Ch*/ + __IO uint32_t DOEPTSIZ; /* dev OUT Endpoint Txfer Size B00h + (ep_num * 20h) + 10h*/ + uint32_t Reserved14[3]; +} +USB_OTG_OUTEPREGS; + +typedef struct +{ + __IO uint32_t HCFG; /* Host Configuration Register 400h*/ + __IO uint32_t HFIR; /* Host Frame Interval Register 404h*/ + __IO uint32_t HFNUM; /* Host Frame Nbr/Frame Remaining 408h*/ + uint32_t Reserved40C; /* Reserved 40Ch*/ + __IO uint32_t HPTXSTS; /* Host Periodic Tx FIFO/ Queue Status 410h*/ + __IO uint32_t HAINT; /* Host All Channels Interrupt Register 414h*/ + __IO uint32_t HAINTMSK; /* Host All Channels Interrupt Mask 418h*/ +} +USB_OTG_HREGS; + +typedef struct +{ + __IO uint32_t HCCHAR; + __IO uint32_t HCSPLT; + __IO uint32_t HCINT; + __IO uint32_t HCINTMSK; + __IO uint32_t HCTSIZ; + uint32_t Reserved[3]; +} +USB_OTG_HC_REGS; + +typedef struct +{ + USB_OTG_GREGS GREGS; + uint32_t RESERVED0[188]; + USB_OTG_HREGS HREGS; + uint32_t RESERVED1[9]; + __IO uint32_t HPRT; + uint32_t RESERVED2[47]; + USB_OTG_HC_REGS HC_REGS[8]; + uint32_t RESERVED3[128]; + USB_OTG_DREGS DREGS; + uint32_t RESERVED4[50]; + USB_OTG_INEPREGS INEP_REGS[4]; + uint32_t RESERVED5[96]; + USB_OTG_OUTEPREGS OUTEP_REGS[4]; + uint32_t RESERVED6[160]; + __IO uint32_t PCGCCTL; + uint32_t RESERVED7[127]; + __IO uint32_t FIFO[4][1024]; +} +USB_OTG_CORE_REGS; + + +#define OTG_FS_BASE (AHB2PERIPH_BASE + 0x0000) +#define OTG_FS ((USB_OTG_CORE_REGS *) OTG_FS_BASE) + +#endif //__USB_OTG_REGS_H__ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ + diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.cpp new file mode 100644 index 000000000..571421d82 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.cpp @@ -0,0 +1,276 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBHAL.h" +#include "USBHID.h" + + +USBHID::USBHID(uint8_t output_report_length, uint8_t input_report_length, uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect): USBDevice(vendor_id, product_id, product_release) +{ + output_length = output_report_length; + input_length = input_report_length; + if(connect) { + USBDevice::connect(); + } +} + + +bool USBHID::send(HID_REPORT *report) +{ + return write(EPINT_IN, report->data, report->length, MAX_HID_REPORT_SIZE); +} + +bool USBHID::sendNB(HID_REPORT *report) +{ + return writeNB(EPINT_IN, report->data, report->length, MAX_HID_REPORT_SIZE); +} + + +bool USBHID::read(HID_REPORT *report) +{ + uint32_t bytesRead = 0; + bool result; + result = USBDevice::readEP(EPINT_OUT, report->data, &bytesRead, MAX_HID_REPORT_SIZE); + if(!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE)) + return false; + report->length = bytesRead; + return result; +} + + +bool USBHID::readNB(HID_REPORT *report) +{ + uint32_t bytesRead = 0; + bool result; + result = USBDevice::readEP_NB(EPINT_OUT, report->data, &bytesRead, MAX_HID_REPORT_SIZE); + // if readEP_NB did not succeed, does not issue a readStart + if (!result) + return false; + report->length = bytesRead; + if(!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE)) + return false; + return result; +} + + +uint16_t USBHID::reportDescLength() { + reportDesc(); + return reportLength; +} + + + +// +// Route callbacks from lower layers to class(es) +// + + +// Called in ISR context +// Called by USBDevice on Endpoint0 request +// This is used to handle extensions to standard requests +// and class specific requests +// Return true if class handles this request +bool USBHID::USBCallback_request() { + bool success = false; + CONTROL_TRANSFER * transfer = getTransferPtr(); + uint8_t *hidDescriptor; + + // Process additional standard requests + + if ((transfer->setup.bmRequestType.Type == STANDARD_TYPE)) + { + switch (transfer->setup.bRequest) + { + case GET_DESCRIPTOR: + switch (DESCRIPTOR_TYPE(transfer->setup.wValue)) + { + case REPORT_DESCRIPTOR: + if ((reportDesc() != NULL) \ + && (reportDescLength() != 0)) + { + transfer->remaining = reportDescLength(); + transfer->ptr = reportDesc(); + transfer->direction = DEVICE_TO_HOST; + success = true; + } + break; + case HID_DESCRIPTOR: + // Find the HID descriptor, after the configuration descriptor + hidDescriptor = findDescriptor(HID_DESCRIPTOR); + if (hidDescriptor != NULL) + { + transfer->remaining = HID_DESCRIPTOR_LENGTH; + transfer->ptr = hidDescriptor; + transfer->direction = DEVICE_TO_HOST; + success = true; + } + break; + + default: + break; + } + break; + default: + break; + } + } + + // Process class-specific requests + + if (transfer->setup.bmRequestType.Type == CLASS_TYPE) + { + switch (transfer->setup.bRequest) + { + case SET_REPORT: + // First byte will be used for report ID + outputReport.data[0] = transfer->setup.wValue & 0xff; + outputReport.length = transfer->setup.wLength + 1; + + transfer->remaining = sizeof(outputReport.data) - 1; + transfer->ptr = &outputReport.data[1]; + transfer->direction = HOST_TO_DEVICE; + transfer->notify = true; + success = true; + default: + break; + } + } + + return success; +} + + +#define DEFAULT_CONFIGURATION (1) + + +// Called in ISR context +// Set configuration. Return false if the +// configuration is not supported +bool USBHID::USBCallback_setConfiguration(uint8_t configuration) { + if (configuration != DEFAULT_CONFIGURATION) { + return false; + } + + // Configure endpoints > 0 + addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT); + addEndpoint(EPINT_OUT, MAX_PACKET_SIZE_EPINT); + + // We activate the endpoint to be able to recceive data + readStart(EPINT_OUT, MAX_PACKET_SIZE_EPINT); + return true; +} + + +uint8_t * USBHID::stringIinterfaceDesc() { + static uint8_t stringIinterfaceDescriptor[] = { + 0x08, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'H',0,'I',0,'D',0, //bString iInterface - HID + }; + return stringIinterfaceDescriptor; +} + +uint8_t * USBHID::stringIproductDesc() { + static uint8_t stringIproductDescriptor[] = { + 0x16, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'H',0,'I',0,'D',0,' ',0,'D',0,'E',0,'V',0,'I',0,'C',0,'E',0 //bString iProduct - HID device + }; + return stringIproductDescriptor; +} + + + +uint8_t * USBHID::reportDesc() { + static uint8_t reportDescriptor[] = { + 0x06, LSB(0xFFAB), MSB(0xFFAB), + 0x0A, LSB(0x0200), MSB(0x0200), + 0xA1, 0x01, // Collection 0x01 + 0x75, 0x08, // report size = 8 bits + 0x15, 0x00, // logical minimum = 0 + 0x26, 0xFF, 0x00, // logical maximum = 255 + 0x95, input_length, // report count + 0x09, 0x01, // usage + 0x81, 0x02, // Input (array) + 0x95, output_length,// report count + 0x09, 0x02, // usage + 0x91, 0x02, // Output (array) + 0xC0 // end collection + + }; + reportLength = sizeof(reportDescriptor); + return reportDescriptor; +} + +#define DEFAULT_CONFIGURATION (1) +#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \ + + (1 * INTERFACE_DESCRIPTOR_LENGTH) \ + + (1 * HID_DESCRIPTOR_LENGTH) \ + + (2 * ENDPOINT_DESCRIPTOR_LENGTH)) + +uint8_t * USBHID::configurationDesc() { + static uint8_t configurationDescriptor[] = { + CONFIGURATION_DESCRIPTOR_LENGTH,// bLength + CONFIGURATION_DESCRIPTOR, // bDescriptorType + LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB) + MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB) + 0x01, // bNumInterfaces + DEFAULT_CONFIGURATION, // bConfigurationValue + 0x00, // iConfiguration + C_RESERVED | C_SELF_POWERED, // bmAttributes + C_POWER(0), // bMaxPower + + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x00, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x02, // bNumEndpoints + HID_CLASS, // bInterfaceClass + HID_SUBCLASS_NONE, // bInterfaceSubClass + HID_PROTOCOL_NONE, // bInterfaceProtocol + 0x00, // iInterface + + HID_DESCRIPTOR_LENGTH, // bLength + HID_DESCRIPTOR, // bDescriptorType + LSB(HID_VERSION_1_11), // bcdHID (LSB) + MSB(HID_VERSION_1_11), // bcdHID (MSB) + 0x00, // bCountryCode + 0x01, // bNumDescriptors + REPORT_DESCRIPTOR, // bDescriptorType + (uint8_t)(LSB(this->reportDescLength())), // wDescriptorLength (LSB) + (uint8_t)(MSB(this->reportDescLength())), // wDescriptorLength (MSB) + + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_IN), // bEndpointAddress + E_INTERRUPT, // bmAttributes + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 1, // bInterval (milliseconds) + + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_OUT), // bEndpointAddress + E_INTERRUPT, // bmAttributes + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 1, // bInterval (milliseconds) + }; + return configurationDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.h new file mode 100644 index 000000000..faa75cb94 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.h @@ -0,0 +1,172 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USB_HID_H +#define USB_HID_H + +/* These headers are included for child class. */ +#include "USBEndpoints.h" +#include "USBDescriptor.h" +#include "USBDevice_Types.h" + +#include "USBHID_Types.h" +#include "USBDevice.h" + + +/** + * USBHID example + * @code + * #include "mbed.h" + * #include "USBHID.h" + * + * USBHID hid; + * HID_REPORT recv; + * BusOut leds(LED1,LED2,LED3,LED4); + * + * int main(void) { + * while (1) { + * hid.read(&recv); + * leds = recv.data[0]; + * } + * } + * @endcode + */ + +class USBHID: public USBDevice { +public: + + /** + * Constructor + * + * @param output_report_length Maximum length of a sent report (up to 64 bytes) (default: 64 bytes) + * @param input_report_length Maximum length of a received report (up to 64 bytes) (default: 64 bytes) + * @param vendor_id Your vendor_id + * @param product_id Your product_id + * @param product_release Your preoduct_release + * @param connect Connect the device + */ + USBHID(uint8_t output_report_length = 64, uint8_t input_report_length = 64, uint16_t vendor_id = 0x1234, uint16_t product_id = 0x0006, uint16_t product_release = 0x0001, bool connect = true); + + + /** + * Send a Report. warning: blocking + * + * @param report Report which will be sent (a report is defined by all data and the length) + * @returns true if successful + */ + bool send(HID_REPORT *report); + + + /** + * Send a Report. warning: non blocking + * + * @param report Report which will be sent (a report is defined by all data and the length) + * @returns true if successful + */ + bool sendNB(HID_REPORT *report); + + /** + * Read a report: blocking + * + * @param report pointer to the report to fill + * @returns true if successful + */ + bool read(HID_REPORT * report); + + /** + * Read a report: non blocking + * + * @param report pointer to the report to fill + * @returns true if successful + */ + bool readNB(HID_REPORT * report); + +protected: + uint16_t reportLength; + + /* + * Get the Report descriptor + * + * @returns pointer to the report descriptor + */ + virtual uint8_t * reportDesc(); + + /* + * Get the length of the report descriptor + * + * @returns the length of the report descriptor + */ + virtual uint16_t reportDescLength(); + + /* + * Get string product descriptor + * + * @returns pointer to the string product descriptor + */ + virtual uint8_t * stringIproductDesc(); + + /* + * Get string interface descriptor + * + * @returns pointer to the string interface descriptor + */ + virtual uint8_t * stringIinterfaceDesc(); + + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + + + /* + * HID Report received by SET_REPORT request. Warning: Called in ISR context + * First byte of data will be the report ID + * + * @param report Data and length received + */ + virtual void HID_callbackSetReport(HID_REPORT *report){}; + + + /* + * Called by USBDevice on Endpoint0 request. Warning: Called in ISR context + * This is used to handle extensions to standard requests + * and class specific requests + * + * @returns true if class handles this request + */ + virtual bool USBCallback_request(); + + + /* + * Called by USBDevice layer. Set configuration of the device. + * For instance, you can add all endpoints that you need on this function. + * + * @param configuration Number of the configuration + * @returns true if class handles this request + */ + virtual bool USBCallback_setConfiguration(uint8_t configuration); + +private: + HID_REPORT outputReport; + uint8_t output_length; + uint8_t input_length; +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID_Types.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID_Types.h new file mode 100644 index 000000000..b8b181bed --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID_Types.h @@ -0,0 +1,91 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBCLASS_HID_TYPES +#define USBCLASS_HID_TYPES + +#include <stdint.h> + +/* */ +#define HID_VERSION_1_11 (0x0111) + +/* HID Class */ +#define HID_CLASS (3) +#define HID_SUBCLASS_NONE (0) +#define HID_PROTOCOL_NONE (0) + +/* Descriptors */ +#define HID_DESCRIPTOR (33) +#define HID_DESCRIPTOR_LENGTH (0x09) +#define REPORT_DESCRIPTOR (34) + +/* Class requests */ +#define GET_REPORT (0x1) +#define GET_IDLE (0x2) +#define SET_REPORT (0x9) +#define SET_IDLE (0xa) + +/* HID Class Report Descriptor */ +/* Short items: size is 0, 1, 2 or 3 specifying 0, 1, 2 or 4 (four) bytes */ +/* of data as per HID Class standard */ + +/* Main items */ +#define INPUT(size) (0x80 | size) +#define OUTPUT(size) (0x90 | size) +#define FEATURE(size) (0xb0 | size) +#define COLLECTION(size) (0xa0 | size) +#define END_COLLECTION(size) (0xc0 | size) + +/* Global items */ +#define USAGE_PAGE(size) (0x04 | size) +#define LOGICAL_MINIMUM(size) (0x14 | size) +#define LOGICAL_MAXIMUM(size) (0x24 | size) +#define PHYSICAL_MINIMUM(size) (0x34 | size) +#define PHYSICAL_MAXIMUM(size) (0x44 | size) +#define UNIT_EXPONENT(size) (0x54 | size) +#define UNIT(size) (0x64 | size) +#define REPORT_SIZE(size) (0x74 | size) +#define REPORT_ID(size) (0x84 | size) +#define REPORT_COUNT(size) (0x94 | size) +#define PUSH(size) (0xa4 | size) +#define POP(size) (0xb4 | size) + +/* Local items */ +#define USAGE(size) (0x08 | size) +#define USAGE_MINIMUM(size) (0x18 | size) +#define USAGE_MAXIMUM(size) (0x28 | size) +#define DESIGNATOR_INDEX(size) (0x38 | size) +#define DESIGNATOR_MINIMUM(size) (0x48 | size) +#define DESIGNATOR_MAXIMUM(size) (0x58 | size) +#define STRING_INDEX(size) (0x78 | size) +#define STRING_MINIMUM(size) (0x88 | size) +#define STRING_MAXIMUM(size) (0x98 | size) +#define DELIMITER(size) (0xa8 | size) + +/* HID Report */ +/* Where report IDs are used the first byte of 'data' will be the */ +/* report ID and 'length' will include this report ID byte. */ + +#define MAX_HID_REPORT_SIZE (64) + +typedef struct { + uint32_t length; + uint8_t data[MAX_HID_REPORT_SIZE]; +} HID_REPORT; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.cpp new file mode 100644 index 000000000..df4ca4798 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.cpp @@ -0,0 +1,553 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" + +#include "USBKeyboard.h" + +#define REPORT_ID_KEYBOARD 1 +#define REPORT_ID_VOLUME 3 + + +typedef struct { + unsigned char usage; + unsigned char modifier; +} KEYMAP; + +#ifdef US_KEYBOARD +/* US keyboard (as HID standard) */ +#define KEYMAP_SIZE (152) +const KEYMAP keymap[KEYMAP_SIZE] = { + {0, 0}, /* NUL */ + {0, 0}, /* SOH */ + {0, 0}, /* STX */ + {0, 0}, /* ETX */ + {0, 0}, /* EOT */ + {0, 0}, /* ENQ */ + {0, 0}, /* ACK */ + {0, 0}, /* BEL */ + {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */ + {0x2b, 0}, /* TAB */ /* Keyboard Tab */ + {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */ + {0, 0}, /* VT */ + {0, 0}, /* FF */ + {0, 0}, /* CR */ + {0, 0}, /* SO */ + {0, 0}, /* SI */ + {0, 0}, /* DEL */ + {0, 0}, /* DC1 */ + {0, 0}, /* DC2 */ + {0, 0}, /* DC3 */ + {0, 0}, /* DC4 */ + {0, 0}, /* NAK */ + {0, 0}, /* SYN */ + {0, 0}, /* ETB */ + {0, 0}, /* CAN */ + {0, 0}, /* EM */ + {0, 0}, /* SUB */ + {0, 0}, /* ESC */ + {0, 0}, /* FS */ + {0, 0}, /* GS */ + {0, 0}, /* RS */ + {0, 0}, /* US */ + {0x2c, 0}, /* */ + {0x1e, KEY_SHIFT}, /* ! */ + {0x34, KEY_SHIFT}, /* " */ + {0x20, KEY_SHIFT}, /* # */ + {0x21, KEY_SHIFT}, /* $ */ + {0x22, KEY_SHIFT}, /* % */ + {0x24, KEY_SHIFT}, /* & */ + {0x34, 0}, /* ' */ + {0x26, KEY_SHIFT}, /* ( */ + {0x27, KEY_SHIFT}, /* ) */ + {0x25, KEY_SHIFT}, /* * */ + {0x2e, KEY_SHIFT}, /* + */ + {0x36, 0}, /* , */ + {0x2d, 0}, /* - */ + {0x37, 0}, /* . */ + {0x38, 0}, /* / */ + {0x27, 0}, /* 0 */ + {0x1e, 0}, /* 1 */ + {0x1f, 0}, /* 2 */ + {0x20, 0}, /* 3 */ + {0x21, 0}, /* 4 */ + {0x22, 0}, /* 5 */ + {0x23, 0}, /* 6 */ + {0x24, 0}, /* 7 */ + {0x25, 0}, /* 8 */ + {0x26, 0}, /* 9 */ + {0x33, KEY_SHIFT}, /* : */ + {0x33, 0}, /* ; */ + {0x36, KEY_SHIFT}, /* < */ + {0x2e, 0}, /* = */ + {0x37, KEY_SHIFT}, /* > */ + {0x38, KEY_SHIFT}, /* ? */ + {0x1f, KEY_SHIFT}, /* @ */ + {0x04, KEY_SHIFT}, /* A */ + {0x05, KEY_SHIFT}, /* B */ + {0x06, KEY_SHIFT}, /* C */ + {0x07, KEY_SHIFT}, /* D */ + {0x08, KEY_SHIFT}, /* E */ + {0x09, KEY_SHIFT}, /* F */ + {0x0a, KEY_SHIFT}, /* G */ + {0x0b, KEY_SHIFT}, /* H */ + {0x0c, KEY_SHIFT}, /* I */ + {0x0d, KEY_SHIFT}, /* J */ + {0x0e, KEY_SHIFT}, /* K */ + {0x0f, KEY_SHIFT}, /* L */ + {0x10, KEY_SHIFT}, /* M */ + {0x11, KEY_SHIFT}, /* N */ + {0x12, KEY_SHIFT}, /* O */ + {0x13, KEY_SHIFT}, /* P */ + {0x14, KEY_SHIFT}, /* Q */ + {0x15, KEY_SHIFT}, /* R */ + {0x16, KEY_SHIFT}, /* S */ + {0x17, KEY_SHIFT}, /* T */ + {0x18, KEY_SHIFT}, /* U */ + {0x19, KEY_SHIFT}, /* V */ + {0x1a, KEY_SHIFT}, /* W */ + {0x1b, KEY_SHIFT}, /* X */ + {0x1c, KEY_SHIFT}, /* Y */ + {0x1d, KEY_SHIFT}, /* Z */ + {0x2f, 0}, /* [ */ + {0x31, 0}, /* \ */ + {0x30, 0}, /* ] */ + {0x23, KEY_SHIFT}, /* ^ */ + {0x2d, KEY_SHIFT}, /* _ */ + {0x35, 0}, /* ` */ + {0x04, 0}, /* a */ + {0x05, 0}, /* b */ + {0x06, 0}, /* c */ + {0x07, 0}, /* d */ + {0x08, 0}, /* e */ + {0x09, 0}, /* f */ + {0x0a, 0}, /* g */ + {0x0b, 0}, /* h */ + {0x0c, 0}, /* i */ + {0x0d, 0}, /* j */ + {0x0e, 0}, /* k */ + {0x0f, 0}, /* l */ + {0x10, 0}, /* m */ + {0x11, 0}, /* n */ + {0x12, 0}, /* o */ + {0x13, 0}, /* p */ + {0x14, 0}, /* q */ + {0x15, 0}, /* r */ + {0x16, 0}, /* s */ + {0x17, 0}, /* t */ + {0x18, 0}, /* u */ + {0x19, 0}, /* v */ + {0x1a, 0}, /* w */ + {0x1b, 0}, /* x */ + {0x1c, 0}, /* y */ + {0x1d, 0}, /* z */ + {0x2f, KEY_SHIFT}, /* { */ + {0x31, KEY_SHIFT}, /* | */ + {0x30, KEY_SHIFT}, /* } */ + {0x35, KEY_SHIFT}, /* ~ */ + {0,0}, /* DEL */ + + {0x3a, 0}, /* F1 */ + {0x3b, 0}, /* F2 */ + {0x3c, 0}, /* F3 */ + {0x3d, 0}, /* F4 */ + {0x3e, 0}, /* F5 */ + {0x3f, 0}, /* F6 */ + {0x40, 0}, /* F7 */ + {0x41, 0}, /* F8 */ + {0x42, 0}, /* F9 */ + {0x43, 0}, /* F10 */ + {0x44, 0}, /* F11 */ + {0x45, 0}, /* F12 */ + + {0x46, 0}, /* PRINT_SCREEN */ + {0x47, 0}, /* SCROLL_LOCK */ + {0x39, 0}, /* CAPS_LOCK */ + {0x53, 0}, /* NUM_LOCK */ + {0x49, 0}, /* INSERT */ + {0x4a, 0}, /* HOME */ + {0x4b, 0}, /* PAGE_UP */ + {0x4e, 0}, /* PAGE_DOWN */ + + {0x4f, 0}, /* RIGHT_ARROW */ + {0x50, 0}, /* LEFT_ARROW */ + {0x51, 0}, /* DOWN_ARROW */ + {0x52, 0}, /* UP_ARROW */ +}; + +#else +/* UK keyboard */ +#define KEYMAP_SIZE (152) +const KEYMAP keymap[KEYMAP_SIZE] = { + {0, 0}, /* NUL */ + {0, 0}, /* SOH */ + {0, 0}, /* STX */ + {0, 0}, /* ETX */ + {0, 0}, /* EOT */ + {0, 0}, /* ENQ */ + {0, 0}, /* ACK */ + {0, 0}, /* BEL */ + {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */ + {0x2b, 0}, /* TAB */ /* Keyboard Tab */ + {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */ + {0, 0}, /* VT */ + {0, 0}, /* FF */ + {0, 0}, /* CR */ + {0, 0}, /* SO */ + {0, 0}, /* SI */ + {0, 0}, /* DEL */ + {0, 0}, /* DC1 */ + {0, 0}, /* DC2 */ + {0, 0}, /* DC3 */ + {0, 0}, /* DC4 */ + {0, 0}, /* NAK */ + {0, 0}, /* SYN */ + {0, 0}, /* ETB */ + {0, 0}, /* CAN */ + {0, 0}, /* EM */ + {0, 0}, /* SUB */ + {0, 0}, /* ESC */ + {0, 0}, /* FS */ + {0, 0}, /* GS */ + {0, 0}, /* RS */ + {0, 0}, /* US */ + {0x2c, 0}, /* */ + {0x1e, KEY_SHIFT}, /* ! */ + {0x1f, KEY_SHIFT}, /* " */ + {0x32, 0}, /* # */ + {0x21, KEY_SHIFT}, /* $ */ + {0x22, KEY_SHIFT}, /* % */ + {0x24, KEY_SHIFT}, /* & */ + {0x34, 0}, /* ' */ + {0x26, KEY_SHIFT}, /* ( */ + {0x27, KEY_SHIFT}, /* ) */ + {0x25, KEY_SHIFT}, /* * */ + {0x2e, KEY_SHIFT}, /* + */ + {0x36, 0}, /* , */ + {0x2d, 0}, /* - */ + {0x37, 0}, /* . */ + {0x38, 0}, /* / */ + {0x27, 0}, /* 0 */ + {0x1e, 0}, /* 1 */ + {0x1f, 0}, /* 2 */ + {0x20, 0}, /* 3 */ + {0x21, 0}, /* 4 */ + {0x22, 0}, /* 5 */ + {0x23, 0}, /* 6 */ + {0x24, 0}, /* 7 */ + {0x25, 0}, /* 8 */ + {0x26, 0}, /* 9 */ + {0x33, KEY_SHIFT}, /* : */ + {0x33, 0}, /* ; */ + {0x36, KEY_SHIFT}, /* < */ + {0x2e, 0}, /* = */ + {0x37, KEY_SHIFT}, /* > */ + {0x38, KEY_SHIFT}, /* ? */ + {0x34, KEY_SHIFT}, /* @ */ + {0x04, KEY_SHIFT}, /* A */ + {0x05, KEY_SHIFT}, /* B */ + {0x06, KEY_SHIFT}, /* C */ + {0x07, KEY_SHIFT}, /* D */ + {0x08, KEY_SHIFT}, /* E */ + {0x09, KEY_SHIFT}, /* F */ + {0x0a, KEY_SHIFT}, /* G */ + {0x0b, KEY_SHIFT}, /* H */ + {0x0c, KEY_SHIFT}, /* I */ + {0x0d, KEY_SHIFT}, /* J */ + {0x0e, KEY_SHIFT}, /* K */ + {0x0f, KEY_SHIFT}, /* L */ + {0x10, KEY_SHIFT}, /* M */ + {0x11, KEY_SHIFT}, /* N */ + {0x12, KEY_SHIFT}, /* O */ + {0x13, KEY_SHIFT}, /* P */ + {0x14, KEY_SHIFT}, /* Q */ + {0x15, KEY_SHIFT}, /* R */ + {0x16, KEY_SHIFT}, /* S */ + {0x17, KEY_SHIFT}, /* T */ + {0x18, KEY_SHIFT}, /* U */ + {0x19, KEY_SHIFT}, /* V */ + {0x1a, KEY_SHIFT}, /* W */ + {0x1b, KEY_SHIFT}, /* X */ + {0x1c, KEY_SHIFT}, /* Y */ + {0x1d, KEY_SHIFT}, /* Z */ + {0x2f, 0}, /* [ */ + {0x64, 0}, /* \ */ + {0x30, 0}, /* ] */ + {0x23, KEY_SHIFT}, /* ^ */ + {0x2d, KEY_SHIFT}, /* _ */ + {0x35, 0}, /* ` */ + {0x04, 0}, /* a */ + {0x05, 0}, /* b */ + {0x06, 0}, /* c */ + {0x07, 0}, /* d */ + {0x08, 0}, /* e */ + {0x09, 0}, /* f */ + {0x0a, 0}, /* g */ + {0x0b, 0}, /* h */ + {0x0c, 0}, /* i */ + {0x0d, 0}, /* j */ + {0x0e, 0}, /* k */ + {0x0f, 0}, /* l */ + {0x10, 0}, /* m */ + {0x11, 0}, /* n */ + {0x12, 0}, /* o */ + {0x13, 0}, /* p */ + {0x14, 0}, /* q */ + {0x15, 0}, /* r */ + {0x16, 0}, /* s */ + {0x17, 0}, /* t */ + {0x18, 0}, /* u */ + {0x19, 0}, /* v */ + {0x1a, 0}, /* w */ + {0x1b, 0}, /* x */ + {0x1c, 0}, /* y */ + {0x1d, 0}, /* z */ + {0x2f, KEY_SHIFT}, /* { */ + {0x64, KEY_SHIFT}, /* | */ + {0x30, KEY_SHIFT}, /* } */ + {0x32, KEY_SHIFT}, /* ~ */ + {0,0}, /* DEL */ + + {0x3a, 0}, /* F1 */ + {0x3b, 0}, /* F2 */ + {0x3c, 0}, /* F3 */ + {0x3d, 0}, /* F4 */ + {0x3e, 0}, /* F5 */ + {0x3f, 0}, /* F6 */ + {0x40, 0}, /* F7 */ + {0x41, 0}, /* F8 */ + {0x42, 0}, /* F9 */ + {0x43, 0}, /* F10 */ + {0x44, 0}, /* F11 */ + {0x45, 0}, /* F12 */ + + {0x46, 0}, /* PRINT_SCREEN */ + {0x47, 0}, /* SCROLL_LOCK */ + {0x39, 0}, /* CAPS_LOCK */ + {0x53, 0}, /* NUM_LOCK */ + {0x49, 0}, /* INSERT */ + {0x4a, 0}, /* HOME */ + {0x4b, 0}, /* PAGE_UP */ + {0x4e, 0}, /* PAGE_DOWN */ + + {0x4f, 0}, /* RIGHT_ARROW */ + {0x50, 0}, /* LEFT_ARROW */ + {0x51, 0}, /* DOWN_ARROW */ + {0x52, 0}, /* UP_ARROW */ +}; +#endif + +uint8_t * USBKeyboard::reportDesc() { + static uint8_t reportDescriptor[] = { + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x06, // Keyboard + COLLECTION(1), 0x01, // Application + REPORT_ID(1), REPORT_ID_KEYBOARD, + + USAGE_PAGE(1), 0x07, // Key Codes + USAGE_MINIMUM(1), 0xE0, + USAGE_MAXIMUM(1), 0xE7, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + REPORT_SIZE(1), 0x01, + REPORT_COUNT(1), 0x08, + INPUT(1), 0x02, // Data, Variable, Absolute + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x08, + INPUT(1), 0x01, // Constant + + + REPORT_COUNT(1), 0x05, + REPORT_SIZE(1), 0x01, + USAGE_PAGE(1), 0x08, // LEDs + USAGE_MINIMUM(1), 0x01, + USAGE_MAXIMUM(1), 0x05, + OUTPUT(1), 0x02, // Data, Variable, Absolute + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x03, + OUTPUT(1), 0x01, // Constant + + + REPORT_COUNT(1), 0x06, + REPORT_SIZE(1), 0x08, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x65, + USAGE_PAGE(1), 0x07, // Key Codes + USAGE_MINIMUM(1), 0x00, + USAGE_MAXIMUM(1), 0x65, + INPUT(1), 0x00, // Data, Array + END_COLLECTION(0), + + // Media Control + USAGE_PAGE(1), 0x0C, + USAGE(1), 0x01, + COLLECTION(1), 0x01, + REPORT_ID(1), REPORT_ID_VOLUME, + USAGE_PAGE(1), 0x0C, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + REPORT_SIZE(1), 0x01, + REPORT_COUNT(1), 0x07, + USAGE(1), 0xB5, // Next Track + USAGE(1), 0xB6, // Previous Track + USAGE(1), 0xB7, // Stop + USAGE(1), 0xCD, // Play / Pause + USAGE(1), 0xE2, // Mute + USAGE(1), 0xE9, // Volume Up + USAGE(1), 0xEA, // Volume Down + INPUT(1), 0x02, // Input (Data, Variable, Absolute) + REPORT_COUNT(1), 0x01, + INPUT(1), 0x01, + END_COLLECTION(0), + }; + reportLength = sizeof(reportDescriptor); + return reportDescriptor; +} + + +bool USBKeyboard::EPINT_OUT_callback() { + uint32_t bytesRead = 0; + uint8_t led[65]; + USBDevice::readEP(EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE); + + // we take led[1] because led[0] is the report ID + lock_status = led[1] & 0x07; + + // We activate the endpoint to be able to recceive data + if (!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE)) + return false; + return true; +} + +uint8_t USBKeyboard::lockStatus() { + return lock_status; +} + +int USBKeyboard::_putc(int c) { + return keyCode(c, keymap[c].modifier); +} + +bool USBKeyboard::keyCode(uint8_t key, uint8_t modifier) { + // Send a simulated keyboard keypress. Returns true if successful. + HID_REPORT report; + + report.data[0] = REPORT_ID_KEYBOARD; + report.data[1] = modifier; + report.data[2] = 0; + report.data[3] = keymap[key].usage; + report.data[4] = 0; + report.data[5] = 0; + report.data[6] = 0; + report.data[7] = 0; + report.data[8] = 0; + + report.length = 9; + + if (!send(&report)) { + return false; + } + + report.data[1] = 0; + report.data[3] = 0; + + if (!send(&report)) { + return false; + } + + return true; + +} + + +bool USBKeyboard::mediaControl(MEDIA_KEY key) { + HID_REPORT report; + + report.data[0] = REPORT_ID_VOLUME; + report.data[1] = (1 << key) & 0x7f; + + report.length = 2; + + if (!send(&report)) { + return false; + } + + report.data[0] = REPORT_ID_VOLUME; + report.data[1] = 0; + + report.length = 2; + + return send(&report); +} + + +#define DEFAULT_CONFIGURATION (1) +#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \ + + (1 * INTERFACE_DESCRIPTOR_LENGTH) \ + + (1 * HID_DESCRIPTOR_LENGTH) \ + + (2 * ENDPOINT_DESCRIPTOR_LENGTH)) + +uint8_t * USBKeyboard::configurationDesc() { + static uint8_t configurationDescriptor[] = { + CONFIGURATION_DESCRIPTOR_LENGTH,// bLength + CONFIGURATION_DESCRIPTOR, // bDescriptorType + LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB) + MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB) + 0x01, // bNumInterfaces + DEFAULT_CONFIGURATION, // bConfigurationValue + 0x00, // iConfiguration + C_RESERVED | C_SELF_POWERED, // bmAttributes + C_POWER(0), // bMaxPowerHello World from Mbed + + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x00, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x02, // bNumEndpoints + HID_CLASS, // bInterfaceClass + 1, // bInterfaceSubClass + 1, // bInterfaceProtocol (keyboard) + 0x00, // iInterface + + HID_DESCRIPTOR_LENGTH, // bLength + HID_DESCRIPTOR, // bDescriptorType + LSB(HID_VERSION_1_11), // bcdHID (LSB) + MSB(HID_VERSION_1_11), // bcdHID (MSB) + 0x00, // bCountryCode + 0x01, // bNumDescriptors + REPORT_DESCRIPTOR, // bDescriptorType + (uint8_t)(LSB(reportDescLength())), // wDescriptorLength (LSB) + (uint8_t)(MSB(reportDescLength())), // wDescriptorLength (MSB) + + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_IN), // bEndpointAddress + E_INTERRUPT, // bmAttributes + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 1, // bInterval (milliseconds) + + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_OUT), // bEndpointAddress + E_INTERRUPT, // bmAttributes + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 1, // bInterval (milliseconds) + }; + return configurationDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.h new file mode 100644 index 000000000..c58ae56f0 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.h @@ -0,0 +1,183 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBKEYBOARD_H +#define USBKEYBOARD_H + +#include "USBHID.h" +#include "Stream.h" + +/* Modifiers */ +enum MODIFIER_KEY { + KEY_CTRL = 1, + KEY_SHIFT = 2, + KEY_ALT = 4, +}; + + +enum MEDIA_KEY { + KEY_NEXT_TRACK, /*!< next Track Button */ + KEY_PREVIOUS_TRACK, /*!< Previous track Button */ + KEY_STOP, /*!< Stop Button */ + KEY_PLAY_PAUSE, /*!< Play/Pause Button */ + KEY_MUTE, /*!< Mute Button */ + KEY_VOLUME_UP, /*!< Volume Up Button */ + KEY_VOLUME_DOWN, /*!< Volume Down Button */ +}; + +enum FUNCTION_KEY { + KEY_F1 = 128, /* F1 key */ + KEY_F2, /* F2 key */ + KEY_F3, /* F3 key */ + KEY_F4, /* F4 key */ + KEY_F5, /* F5 key */ + KEY_F6, /* F6 key */ + KEY_F7, /* F7 key */ + KEY_F8, /* F8 key */ + KEY_F9, /* F9 key */ + KEY_F10, /* F10 key */ + KEY_F11, /* F11 key */ + KEY_F12, /* F12 key */ + + KEY_PRINT_SCREEN, /* Print Screen key */ + KEY_SCROLL_LOCK, /* Scroll lock */ + KEY_CAPS_LOCK, /* caps lock */ + KEY_NUM_LOCK, /* num lock */ + KEY_INSERT, /* Insert key */ + KEY_HOME, /* Home key */ + KEY_PAGE_UP, /* Page Up key */ + KEY_PAGE_DOWN, /* Page Down key */ + + RIGHT_ARROW, /* Right arrow */ + LEFT_ARROW, /* Left arrow */ + DOWN_ARROW, /* Down arrow */ + UP_ARROW, /* Up arrow */ +}; + +/** + * USBKeyboard example + * @code + * + * #include "mbed.h" + * #include "USBKeyboard.h" + * + * USBKeyboard key; + * + * int main(void) + * { + * while (1) + * { + * key.printf("Hello World\r\n"); + * wait(1); + * } + * } + * + * @endcode + */ +class USBKeyboard: public USBHID, public Stream { +public: + + /** + * Constructor + * + * + * @param leds Leds bus: first: NUM_LOCK, second: CAPS_LOCK, third: SCROLL_LOCK + * @param vendor_id Your vendor_id (default: 0x1235) + * @param product_id Your product_id (default: 0x0050) + * @param product_release Your preoduct_release (default: 0x0001) + * + */ + USBKeyboard(uint16_t vendor_id = 0x1235, uint16_t product_id = 0x0050, uint16_t product_release = 0x0001): + USBHID(0, 0, vendor_id, product_id, product_release, false) { + lock_status = 0; + connect(); + }; + + /** + * To send a character defined by a modifier(CTRL, SHIFT, ALT) and the key + * + * @code + * //To send CTRL + s (save) + * keyboard.keyCode('s', KEY_CTRL); + * @endcode + * + * @param modifier bit 0: KEY_CTRL, bit 1: KEY_SHIFT, bit 2: KEY_ALT (default: 0) + * @param key character to send + * @returns true if there is no error, false otherwise + */ + bool keyCode(uint8_t key, uint8_t modifier = 0); + + /** + * Send a character + * + * @param c character to be sent + * @returns true if there is no error, false otherwise + */ + virtual int _putc(int c); + + /** + * Control media keys + * + * @param key media key pressed (KEY_NEXT_TRACK, KEY_PREVIOUS_TRACK, KEY_STOP, KEY_PLAY_PAUSE, KEY_MUTE, KEY_VOLUME_UP, KEY_VOLUME_DOWN) + * @returns true if there is no error, false otherwise + */ + bool mediaControl(MEDIA_KEY key); + + /* + * To define the report descriptor. Warning: this method has to store the length of the report descriptor in reportLength. + * + * @returns pointer to the report descriptor + */ + virtual uint8_t * reportDesc(); + + /* + * Called when a data is received on the OUT endpoint. Useful to switch on LED of LOCK keys + * + * @returns if handle by subclass, return true + */ + virtual bool EPINT_OUT_callback(); + + /** + * Read status of lock keys. Useful to switch-on/off leds according to key pressed. Only the first three bits of the result is important: + * - First bit: NUM_LOCK + * - Second bit: CAPS_LOCK + * - Third bit: SCROLL_LOCK + * + * @returns status of lock keys + */ + uint8_t lockStatus(); + +protected: + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + +private: + //dummy otherwise it doesn,t compile (we must define all methods of an abstract class) + virtual int _getc() { + return -1; + }; + + uint8_t lock_status; + +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.cpp new file mode 100644 index 000000000..980e67909 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.cpp @@ -0,0 +1,245 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBMouse.h" + +bool USBMouse::update(int16_t x, int16_t y, uint8_t button, int8_t z) { + switch (mouse_type) { + case REL_MOUSE: + while (x > 127) { + if (!mouseSend(127, 0, button, z)) return false; + x = x - 127; + } + while (x < -128) { + if (!mouseSend(-128, 0, button, z)) return false; + x = x + 128; + } + while (y > 127) { + if (!mouseSend(0, 127, button, z)) return false; + y = y - 127; + } + while (y < -128) { + if (!mouseSend(0, -128, button, z)) return false; + y = y + 128; + } + return mouseSend(x, y, button, z); + case ABS_MOUSE: + HID_REPORT report; + + report.data[0] = x & 0xff; + report.data[1] = (x >> 8) & 0xff; + report.data[2] = y & 0xff; + report.data[3] = (y >> 8) & 0xff; + report.data[4] = -z; + report.data[5] = button & 0x07; + + report.length = 6; + + return send(&report); + default: + return false; + } +} + +bool USBMouse::mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z) { + HID_REPORT report; + report.data[0] = buttons & 0x07; + report.data[1] = x; + report.data[2] = y; + report.data[3] = -z; // >0 to scroll down, <0 to scroll up + + report.length = 4; + + return send(&report); +} + +bool USBMouse::move(int16_t x, int16_t y) { + return update(x, y, button, 0); +} + +bool USBMouse::scroll(int8_t z) { + return update(0, 0, button, z); +} + + +bool USBMouse::doubleClick() { + if (!click(MOUSE_LEFT)) + return false; + wait(0.1); + return click(MOUSE_LEFT); +} + +bool USBMouse::click(uint8_t button) { + if (!update(0, 0, button, 0)) + return false; + wait(0.01); + return update(0, 0, 0, 0); +} + +bool USBMouse::press(uint8_t button_) { + button = button_ & 0x07; + return update(0, 0, button, 0); +} + +bool USBMouse::release(uint8_t button_) { + button = (button & (~button_)) & 0x07; + return update(0, 0, button, 0); +} + + +uint8_t * USBMouse::reportDesc() { + + if (mouse_type == REL_MOUSE) { + static uint8_t reportDescriptor[] = { + USAGE_PAGE(1), 0x01, // Genric Desktop + USAGE(1), 0x02, // Mouse + COLLECTION(1), 0x01, // Application + USAGE(1), 0x01, // Pointer + COLLECTION(1), 0x00, // Physical + + REPORT_COUNT(1), 0x03, + REPORT_SIZE(1), 0x01, + USAGE_PAGE(1), 0x09, // Buttons + USAGE_MINIMUM(1), 0x1, + USAGE_MAXIMUM(1), 0x3, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + INPUT(1), 0x02, + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x05, + INPUT(1), 0x01, + + REPORT_COUNT(1), 0x03, + REPORT_SIZE(1), 0x08, + USAGE_PAGE(1), 0x01, + USAGE(1), 0x30, // X + USAGE(1), 0x31, // Y + USAGE(1), 0x38, // scroll + LOGICAL_MINIMUM(1), 0x81, + LOGICAL_MAXIMUM(1), 0x7f, + INPUT(1), 0x06, // Relative data + + END_COLLECTION(0), + END_COLLECTION(0), + }; + reportLength = sizeof(reportDescriptor); + return reportDescriptor; + } else if (mouse_type == ABS_MOUSE) { + static uint8_t reportDescriptor[] = { + + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x02, // Mouse + COLLECTION(1), 0x01, // Application + USAGE(1), 0x01, // Pointer + COLLECTION(1), 0x00, // Physical + + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x30, // X + USAGE(1), 0x31, // Y + LOGICAL_MINIMUM(1), 0x00, // 0 + LOGICAL_MAXIMUM(2), 0xff, 0x7f, // 32767 + REPORT_SIZE(1), 0x10, + REPORT_COUNT(1), 0x02, + INPUT(1), 0x02, // Data, Variable, Absolute + + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x38, // scroll + LOGICAL_MINIMUM(1), 0x81, // -127 + LOGICAL_MAXIMUM(1), 0x7f, // 127 + REPORT_SIZE(1), 0x08, + REPORT_COUNT(1), 0x01, + INPUT(1), 0x06, // Data, Variable, Relative + + USAGE_PAGE(1), 0x09, // Buttons + USAGE_MINIMUM(1), 0x01, + USAGE_MAXIMUM(1), 0x03, + LOGICAL_MINIMUM(1), 0x00, // 0 + LOGICAL_MAXIMUM(1), 0x01, // 1 + REPORT_COUNT(1), 0x03, + REPORT_SIZE(1), 0x01, + INPUT(1), 0x02, // Data, Variable, Absolute + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x05, + INPUT(1), 0x01, // Constant + + END_COLLECTION(0), + END_COLLECTION(0) + }; + reportLength = sizeof(reportDescriptor); + return reportDescriptor; + } + return NULL; +} + +#define DEFAULT_CONFIGURATION (1) +#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \ + + (1 * INTERFACE_DESCRIPTOR_LENGTH) \ + + (1 * HID_DESCRIPTOR_LENGTH) \ + + (2 * ENDPOINT_DESCRIPTOR_LENGTH)) + +uint8_t * USBMouse::configurationDesc() { + static uint8_t configurationDescriptor[] = { + CONFIGURATION_DESCRIPTOR_LENGTH,// bLength + CONFIGURATION_DESCRIPTOR, // bDescriptorType + LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB) + MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB) + 0x01, // bNumInterfaces + DEFAULT_CONFIGURATION, // bConfigurationValue + 0x00, // iConfiguration + C_RESERVED | C_SELF_POWERED, // bmAttributes + C_POWER(0), // bMaxPowerHello World from Mbed + + INTERFACE_DESCRIPTOR_LENGTH, // bLength + INTERFACE_DESCRIPTOR, // bDescriptorType + 0x00, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x02, // bNumEndpoints + HID_CLASS, // bInterfaceClass + 1, // bInterfaceSubClass + 2, // bInterfaceProtocol (mouse) + 0x00, // iInterface + + HID_DESCRIPTOR_LENGTH, // bLength + HID_DESCRIPTOR, // bDescriptorType + LSB(HID_VERSION_1_11), // bcdHID (LSB) + MSB(HID_VERSION_1_11), // bcdHID (MSB) + 0x00, // bCountryCode + 0x01, // bNumDescriptors + REPORT_DESCRIPTOR, // bDescriptorType + (uint8_t)(LSB(reportDescLength())), // wDescriptorLength (LSB) + (uint8_t)(MSB(reportDescLength())), // wDescriptorLength (MSB) + + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_IN), // bEndpointAddress + E_INTERRUPT, // bmAttributes + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 1, // bInterval (milliseconds) + + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_OUT), // bEndpointAddress + E_INTERRUPT, // bmAttributes + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 1, // bInterval (milliseconds) + }; + return configurationDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.h new file mode 100644 index 000000000..7aa426334 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.h @@ -0,0 +1,209 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBMOUSE_H +#define USBMOUSE_H + +#include "USBHID.h" + +#define REPORT_ID_MOUSE 2 + +/* Common usage */ + +enum MOUSE_BUTTON +{ + MOUSE_LEFT = 1, + MOUSE_RIGHT = 2, + MOUSE_MIDDLE = 4, +}; + +/* X and Y limits */ +/* These values do not directly map to screen pixels */ +/* Zero may be interpreted as meaning 'no movement' */ +#define X_MIN_ABS (1) /*!< Minimum value on x-axis */ +#define Y_MIN_ABS (1) /*!< Minimum value on y-axis */ +#define X_MAX_ABS (0x7fff) /*!< Maximum value on x-axis */ +#define Y_MAX_ABS (0x7fff) /*!< Maximum value on y-axis */ + +#define X_MIN_REL (-127) /*!< The maximum value that we can move to the left on the x-axis */ +#define Y_MIN_REL (-127) /*!< The maximum value that we can move up on the y-axis */ +#define X_MAX_REL (127) /*!< The maximum value that we can move to the right on the x-axis */ +#define Y_MAX_REL (127) /*!< The maximum value that we can move down on the y-axis */ + +enum MOUSE_TYPE +{ + ABS_MOUSE, + REL_MOUSE, +}; + +/** + * + * USBMouse example + * @code + * #include "mbed.h" + * #include "USBMouse.h" + * + * USBMouse mouse; + * + * int main(void) + * { + * while (1) + * { + * mouse.move(20, 0); + * wait(0.5); + * } + * } + * + * @endcode + * + * + * @code + * #include "mbed.h" + * #include "USBMouse.h" + * #include <math.h> + * + * USBMouse mouse(ABS_MOUSE); + * + * int main(void) + * { + * uint16_t x_center = (X_MAX_ABS - X_MIN_ABS)/2; + * uint16_t y_center = (Y_MAX_ABS - Y_MIN_ABS)/2; + * uint16_t x_screen = 0; + * uint16_t y_screen = 0; + * + * uint32_t x_origin = x_center; + * uint32_t y_origin = y_center; + * uint32_t radius = 5000; + * uint32_t angle = 0; + * + * while (1) + * { + * x_screen = x_origin + cos((double)angle*3.14/180.0)*radius; + * y_screen = y_origin + sin((double)angle*3.14/180.0)*radius; + * + * mouse.move(x_screen, y_screen); + * angle += 3; + * wait(0.01); + * } + * } + * + * @endcode + */ +class USBMouse: public USBHID +{ + public: + + /** + * Constructor + * + * @param mouse_type Mouse type: ABS_MOUSE (absolute mouse) or REL_MOUSE (relative mouse) (default: REL_MOUSE) + * @param vendor_id Your vendor_id (default: 0x1234) + * @param product_id Your product_id (default: 0x0001) + * @param product_release Your preoduct_release (default: 0x0001) + * + */ + USBMouse(MOUSE_TYPE mouse_type = REL_MOUSE, uint16_t vendor_id = 0x1234, uint16_t product_id = 0x0001, uint16_t product_release = 0x0001): + USBHID(0, 0, vendor_id, product_id, product_release, false) + { + button = 0; + this->mouse_type = mouse_type; + connect(); + }; + + /** + * Write a state of the mouse + * + * @param x x-axis position + * @param y y-axis position + * @param buttons buttons state (first bit represents MOUSE_LEFT, second bit MOUSE_RIGHT and third bit MOUSE_MIDDLE) + * @param z wheel state (>0 to scroll down, <0 to scroll up) + * @returns true if there is no error, false otherwise + */ + bool update(int16_t x, int16_t y, uint8_t buttons, int8_t z); + + + /** + * Move the cursor to (x, y) + * + * @param x-axis position + * @param y-axis position + * @returns true if there is no error, false otherwise + */ + bool move(int16_t x, int16_t y); + + /** + * Press one or several buttons + * + * @param button button state (ex: press(MOUSE_LEFT)) + * @returns true if there is no error, false otherwise + */ + bool press(uint8_t button); + + /** + * Release one or several buttons + * + * @param button button state (ex: release(MOUSE_LEFT)) + * @returns true if there is no error, false otherwise + */ + bool release(uint8_t button); + + /** + * Double click (MOUSE_LEFT) + * + * @returns true if there is no error, false otherwise + */ + bool doubleClick(); + + /** + * Click + * + * @param button state of the buttons ( ex: clic(MOUSE_LEFT)) + * @returns true if there is no error, false otherwise + */ + bool click(uint8_t button); + + /** + * Scrolling + * + * @param z value of the wheel (>0 to go down, <0 to go up) + * @returns true if there is no error, false otherwise + */ + bool scroll(int8_t z); + + /* + * To define the report descriptor. Warning: this method has to store the length of the report descriptor in reportLength. + * + * @returns pointer to the report descriptor + */ + virtual uint8_t * reportDesc(); + + protected: + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + + private: + MOUSE_TYPE mouse_type; + uint8_t button; + bool mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z); +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.cpp new file mode 100644 index 000000000..cd6809120 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.cpp @@ -0,0 +1,706 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBMouseKeyboard.h" + +typedef struct { + unsigned char usage; + unsigned char modifier; +} KEYMAP; + +#ifdef US_KEYBOARD +/* US keyboard (as HID standard) */ +#define KEYMAP_SIZE (152) +const KEYMAP keymap[KEYMAP_SIZE] = { + {0, 0}, /* NUL */ + {0, 0}, /* SOH */ + {0, 0}, /* STX */ + {0, 0}, /* ETX */ + {0, 0}, /* EOT */ + {0, 0}, /* ENQ */ + {0, 0}, /* ACK */ + {0, 0}, /* BEL */ + {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */ + {0x2b, 0}, /* TAB */ /* Keyboard Tab */ + {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */ + {0, 0}, /* VT */ + {0, 0}, /* FF */ + {0, 0}, /* CR */ + {0, 0}, /* SO */ + {0, 0}, /* SI */ + {0, 0}, /* DEL */ + {0, 0}, /* DC1 */ + {0, 0}, /* DC2 */ + {0, 0}, /* DC3 */ + {0, 0}, /* DC4 */ + {0, 0}, /* NAK */ + {0, 0}, /* SYN */ + {0, 0}, /* ETB */ + {0, 0}, /* CAN */ + {0, 0}, /* EM */ + {0, 0}, /* SUB */ + {0, 0}, /* ESC */ + {0, 0}, /* FS */ + {0, 0}, /* GS */ + {0, 0}, /* RS */ + {0, 0}, /* US */ + {0x2c, 0}, /* */ + {0x1e, KEY_SHIFT}, /* ! */ + {0x34, KEY_SHIFT}, /* " */ + {0x20, KEY_SHIFT}, /* # */ + {0x21, KEY_SHIFT}, /* $ */ + {0x22, KEY_SHIFT}, /* % */ + {0x24, KEY_SHIFT}, /* & */ + {0x34, 0}, /* ' */ + {0x26, KEY_SHIFT}, /* ( */ + {0x27, KEY_SHIFT}, /* ) */ + {0x25, KEY_SHIFT}, /* * */ + {0x2e, KEY_SHIFT}, /* + */ + {0x36, 0}, /* , */ + {0x2d, 0}, /* - */ + {0x37, 0}, /* . */ + {0x38, 0}, /* / */ + {0x27, 0}, /* 0 */ + {0x1e, 0}, /* 1 */ + {0x1f, 0}, /* 2 */ + {0x20, 0}, /* 3 */ + {0x21, 0}, /* 4 */ + {0x22, 0}, /* 5 */ + {0x23, 0}, /* 6 */ + {0x24, 0}, /* 7 */ + {0x25, 0}, /* 8 */ + {0x26, 0}, /* 9 */ + {0x33, KEY_SHIFT}, /* : */ + {0x33, 0}, /* ; */ + {0x36, KEY_SHIFT}, /* < */ + {0x2e, 0}, /* = */ + {0x37, KEY_SHIFT}, /* > */ + {0x38, KEY_SHIFT}, /* ? */ + {0x1f, KEY_SHIFT}, /* @ */ + {0x04, KEY_SHIFT}, /* A */ + {0x05, KEY_SHIFT}, /* B */ + {0x06, KEY_SHIFT}, /* C */ + {0x07, KEY_SHIFT}, /* D */ + {0x08, KEY_SHIFT}, /* E */ + {0x09, KEY_SHIFT}, /* F */ + {0x0a, KEY_SHIFT}, /* G */ + {0x0b, KEY_SHIFT}, /* H */ + {0x0c, KEY_SHIFT}, /* I */ + {0x0d, KEY_SHIFT}, /* J */ + {0x0e, KEY_SHIFT}, /* K */ + {0x0f, KEY_SHIFT}, /* L */ + {0x10, KEY_SHIFT}, /* M */ + {0x11, KEY_SHIFT}, /* N */ + {0x12, KEY_SHIFT}, /* O */ + {0x13, KEY_SHIFT}, /* P */ + {0x14, KEY_SHIFT}, /* Q */ + {0x15, KEY_SHIFT}, /* R */ + {0x16, KEY_SHIFT}, /* S */ + {0x17, KEY_SHIFT}, /* T */ + {0x18, KEY_SHIFT}, /* U */ + {0x19, KEY_SHIFT}, /* V */ + {0x1a, KEY_SHIFT}, /* W */ + {0x1b, KEY_SHIFT}, /* X */ + {0x1c, KEY_SHIFT}, /* Y */ + {0x1d, KEY_SHIFT}, /* Z */ + {0x2f, 0}, /* [ */ + {0x31, 0}, /* \ */ + {0x30, 0}, /* ] */ + {0x23, KEY_SHIFT}, /* ^ */ + {0x2d, KEY_SHIFT}, /* _ */ + {0x35, 0}, /* ` */ + {0x04, 0}, /* a */ + {0x05, 0}, /* b */ + {0x06, 0}, /* c */ + {0x07, 0}, /* d */ + {0x08, 0}, /* e */ + {0x09, 0}, /* f */ + {0x0a, 0}, /* g */ + {0x0b, 0}, /* h */ + {0x0c, 0}, /* i */ + {0x0d, 0}, /* j */ + {0x0e, 0}, /* k */ + {0x0f, 0}, /* l */ + {0x10, 0}, /* m */ + {0x11, 0}, /* n */ + {0x12, 0}, /* o */ + {0x13, 0}, /* p */ + {0x14, 0}, /* q */ + {0x15, 0}, /* r */ + {0x16, 0}, /* s */ + {0x17, 0}, /* t */ + {0x18, 0}, /* u */ + {0x19, 0}, /* v */ + {0x1a, 0}, /* w */ + {0x1b, 0}, /* x */ + {0x1c, 0}, /* y */ + {0x1d, 0}, /* z */ + {0x2f, KEY_SHIFT}, /* { */ + {0x31, KEY_SHIFT}, /* | */ + {0x30, KEY_SHIFT}, /* } */ + {0x35, KEY_SHIFT}, /* ~ */ + {0,0}, /* DEL */ + + {0x3a, 0}, /* F1 */ + {0x3b, 0}, /* F2 */ + {0x3c, 0}, /* F3 */ + {0x3d, 0}, /* F4 */ + {0x3e, 0}, /* F5 */ + {0x3f, 0}, /* F6 */ + {0x40, 0}, /* F7 */ + {0x41, 0}, /* F8 */ + {0x42, 0}, /* F9 */ + {0x43, 0}, /* F10 */ + {0x44, 0}, /* F11 */ + {0x45, 0}, /* F12 */ + + {0x46, 0}, /* PRINT_SCREEN */ + {0x47, 0}, /* SCROLL_LOCK */ + {0x39, 0}, /* CAPS_LOCK */ + {0x53, 0}, /* NUM_LOCK */ + {0x49, 0}, /* INSERT */ + {0x4a, 0}, /* HOME */ + {0x4b, 0}, /* PAGE_UP */ + {0x4e, 0}, /* PAGE_DOWN */ + + {0x4f, 0}, /* RIGHT_ARROW */ + {0x50, 0}, /* LEFT_ARROW */ + {0x51, 0}, /* DOWN_ARROW */ + {0x52, 0}, /* UP_ARROW */ +}; + +#else +/* UK keyboard */ +#define KEYMAP_SIZE (152) +const KEYMAP keymap[KEYMAP_SIZE] = { + {0, 0}, /* NUL */ + {0, 0}, /* SOH */ + {0, 0}, /* STX */ + {0, 0}, /* ETX */ + {0, 0}, /* EOT */ + {0, 0}, /* ENQ */ + {0, 0}, /* ACK */ + {0, 0}, /* BEL */ + {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */ + {0x2b, 0}, /* TAB */ /* Keyboard Tab */ + {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */ + {0, 0}, /* VT */ + {0, 0}, /* FF */ + {0, 0}, /* CR */ + {0, 0}, /* SO */ + {0, 0}, /* SI */ + {0, 0}, /* DEL */ + {0, 0}, /* DC1 */ + {0, 0}, /* DC2 */ + {0, 0}, /* DC3 */ + {0, 0}, /* DC4 */ + {0, 0}, /* NAK */ + {0, 0}, /* SYN */ + {0, 0}, /* ETB */ + {0, 0}, /* CAN */ + {0, 0}, /* EM */ + {0, 0}, /* SUB */ + {0, 0}, /* ESC */ + {0, 0}, /* FS */ + {0, 0}, /* GS */ + {0, 0}, /* RS */ + {0, 0}, /* US */ + {0x2c, 0}, /* */ + {0x1e, KEY_SHIFT}, /* ! */ + {0x1f, KEY_SHIFT}, /* " */ + {0x32, 0}, /* # */ + {0x21, KEY_SHIFT}, /* $ */ + {0x22, KEY_SHIFT}, /* % */ + {0x24, KEY_SHIFT}, /* & */ + {0x34, 0}, /* ' */ + {0x26, KEY_SHIFT}, /* ( */ + {0x27, KEY_SHIFT}, /* ) */ + {0x25, KEY_SHIFT}, /* * */ + {0x2e, KEY_SHIFT}, /* + */ + {0x36, 0}, /* , */ + {0x2d, 0}, /* - */ + {0x37, 0}, /* . */ + {0x38, 0}, /* / */ + {0x27, 0}, /* 0 */ + {0x1e, 0}, /* 1 */ + {0x1f, 0}, /* 2 */ + {0x20, 0}, /* 3 */ + {0x21, 0}, /* 4 */ + {0x22, 0}, /* 5 */ + {0x23, 0}, /* 6 */ + {0x24, 0}, /* 7 */ + {0x25, 0}, /* 8 */ + {0x26, 0}, /* 9 */ + {0x33, KEY_SHIFT}, /* : */ + {0x33, 0}, /* ; */ + {0x36, KEY_SHIFT}, /* < */ + {0x2e, 0}, /* = */ + {0x37, KEY_SHIFT}, /* > */ + {0x38, KEY_SHIFT}, /* ? */ + {0x34, KEY_SHIFT}, /* @ */ + {0x04, KEY_SHIFT}, /* A */ + {0x05, KEY_SHIFT}, /* B */ + {0x06, KEY_SHIFT}, /* C */ + {0x07, KEY_SHIFT}, /* D */ + {0x08, KEY_SHIFT}, /* E */ + {0x09, KEY_SHIFT}, /* F */ + {0x0a, KEY_SHIFT}, /* G */ + {0x0b, KEY_SHIFT}, /* H */ + {0x0c, KEY_SHIFT}, /* I */ + {0x0d, KEY_SHIFT}, /* J */ + {0x0e, KEY_SHIFT}, /* K */ + {0x0f, KEY_SHIFT}, /* L */ + {0x10, KEY_SHIFT}, /* M */ + {0x11, KEY_SHIFT}, /* N */ + {0x12, KEY_SHIFT}, /* O */ + {0x13, KEY_SHIFT}, /* P */ + {0x14, KEY_SHIFT}, /* Q */ + {0x15, KEY_SHIFT}, /* R */ + {0x16, KEY_SHIFT}, /* S */ + {0x17, KEY_SHIFT}, /* T */ + {0x18, KEY_SHIFT}, /* U */ + {0x19, KEY_SHIFT}, /* V */ + {0x1a, KEY_SHIFT}, /* W */ + {0x1b, KEY_SHIFT}, /* X */ + {0x1c, KEY_SHIFT}, /* Y */ + {0x1d, KEY_SHIFT}, /* Z */ + {0x2f, 0}, /* [ */ + {0x64, 0}, /* \ */ + {0x30, 0}, /* ] */ + {0x23, KEY_SHIFT}, /* ^ */ + {0x2d, KEY_SHIFT}, /* _ */ + {0x35, 0}, /* ` */ + {0x04, 0}, /* a */ + {0x05, 0}, /* b */ + {0x06, 0}, /* c */ + {0x07, 0}, /* d */ + {0x08, 0}, /* e */ + {0x09, 0}, /* f */ + {0x0a, 0}, /* g */ + {0x0b, 0}, /* h */ + {0x0c, 0}, /* i */ + {0x0d, 0}, /* j */ + {0x0e, 0}, /* k */ + {0x0f, 0}, /* l */ + {0x10, 0}, /* m */ + {0x11, 0}, /* n */ + {0x12, 0}, /* o */ + {0x13, 0}, /* p */ + {0x14, 0}, /* q */ + {0x15, 0}, /* r */ + {0x16, 0}, /* s */ + {0x17, 0}, /* t */ + {0x18, 0}, /* u */ + {0x19, 0}, /* v */ + {0x1a, 0}, /* w */ + {0x1b, 0}, /* x */ + {0x1c, 0}, /* y */ + {0x1d, 0}, /* z */ + {0x2f, KEY_SHIFT}, /* { */ + {0x64, KEY_SHIFT}, /* | */ + {0x30, KEY_SHIFT}, /* } */ + {0x32, KEY_SHIFT}, /* ~ */ + {0,0}, /* DEL */ + + {0x3a, 0}, /* F1 */ + {0x3b, 0}, /* F2 */ + {0x3c, 0}, /* F3 */ + {0x3d, 0}, /* F4 */ + {0x3e, 0}, /* F5 */ + {0x3f, 0}, /* F6 */ + {0x40, 0}, /* F7 */ + {0x41, 0}, /* F8 */ + {0x42, 0}, /* F9 */ + {0x43, 0}, /* F10 */ + {0x44, 0}, /* F11 */ + {0x45, 0}, /* F12 */ + + {0x46, 0}, /* PRINT_SCREEN */ + {0x47, 0}, /* SCROLL_LOCK */ + {0x39, 0}, /* CAPS_LOCK */ + {0x53, 0}, /* NUM_LOCK */ + {0x49, 0}, /* INSERT */ + {0x4a, 0}, /* HOME */ + {0x4b, 0}, /* PAGE_UP */ + {0x4e, 0}, /* PAGE_DOWN */ + + {0x4f, 0}, /* RIGHT_ARROW */ + {0x50, 0}, /* LEFT_ARROW */ + {0x51, 0}, /* DOWN_ARROW */ + {0x52, 0}, /* UP_ARROW */ +}; +#endif + + +uint8_t * USBMouseKeyboard::reportDesc() { + if (mouse_type == REL_MOUSE) { + static uint8_t reportDescriptor[] = { + // Keyboard + USAGE_PAGE(1), 0x01, + USAGE(1), 0x06, + COLLECTION(1), 0x01, + REPORT_ID(1), REPORT_ID_KEYBOARD, + USAGE_PAGE(1), 0x07, + USAGE_MINIMUM(1), 0xE0, + USAGE_MAXIMUM(1), 0xE7, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + REPORT_SIZE(1), 0x01, + REPORT_COUNT(1), 0x08, + INPUT(1), 0x02, + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x08, + INPUT(1), 0x01, + REPORT_COUNT(1), 0x05, + REPORT_SIZE(1), 0x01, + USAGE_PAGE(1), 0x08, + USAGE_MINIMUM(1), 0x01, + USAGE_MAXIMUM(1), 0x05, + OUTPUT(1), 0x02, + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x03, + OUTPUT(1), 0x01, + REPORT_COUNT(1), 0x06, + REPORT_SIZE(1), 0x08, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(2), 0xff, 0x00, + USAGE_PAGE(1), 0x07, + USAGE_MINIMUM(1), 0x00, + USAGE_MAXIMUM(2), 0xff, 0x00, + INPUT(1), 0x00, + END_COLLECTION(0), + + // Mouse + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x02, // Mouse + COLLECTION(1), 0x01, // Application + USAGE(1), 0x01, // Pointer + COLLECTION(1), 0x00, // Physical + REPORT_ID(1), REPORT_ID_MOUSE, + REPORT_COUNT(1), 0x03, + REPORT_SIZE(1), 0x01, + USAGE_PAGE(1), 0x09, // Buttons + USAGE_MINIMUM(1), 0x1, + USAGE_MAXIMUM(1), 0x3, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + INPUT(1), 0x02, + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x05, + INPUT(1), 0x01, + REPORT_COUNT(1), 0x03, + REPORT_SIZE(1), 0x08, + USAGE_PAGE(1), 0x01, + USAGE(1), 0x30, // X + USAGE(1), 0x31, // Y + USAGE(1), 0x38, // scroll + LOGICAL_MINIMUM(1), 0x81, + LOGICAL_MAXIMUM(1), 0x7f, + INPUT(1), 0x06, + END_COLLECTION(0), + END_COLLECTION(0), + + + // Media Control + USAGE_PAGE(1), 0x0C, + USAGE(1), 0x01, + COLLECTION(1), 0x01, + REPORT_ID(1), REPORT_ID_VOLUME, + USAGE_PAGE(1), 0x0C, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + REPORT_SIZE(1), 0x01, + REPORT_COUNT(1), 0x07, + USAGE(1), 0xB5, // Next Track + USAGE(1), 0xB6, // Previous Track + USAGE(1), 0xB7, // Stop + USAGE(1), 0xCD, // Play / Pause + USAGE(1), 0xE2, // Mute + USAGE(1), 0xE9, // Volume Up + USAGE(1), 0xEA, // Volume Down + INPUT(1), 0x02, // Input (Data, Variable, Absolute) + REPORT_COUNT(1), 0x01, + INPUT(1), 0x01, + END_COLLECTION(0), + }; + reportLength = sizeof(reportDescriptor); + return reportDescriptor; + } else if (mouse_type == ABS_MOUSE) { + static uint8_t reportDescriptor[] = { + + // Keyboard + USAGE_PAGE(1), 0x01, + USAGE(1), 0x06, + COLLECTION(1), 0x01, + REPORT_ID(1), REPORT_ID_KEYBOARD, + USAGE_PAGE(1), 0x07, + USAGE_MINIMUM(1), 0xE0, + USAGE_MAXIMUM(1), 0xE7, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + REPORT_SIZE(1), 0x01, + REPORT_COUNT(1), 0x08, + INPUT(1), 0x02, + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x08, + INPUT(1), 0x01, + REPORT_COUNT(1), 0x05, + REPORT_SIZE(1), 0x01, + USAGE_PAGE(1), 0x08, + USAGE_MINIMUM(1), 0x01, + USAGE_MAXIMUM(1), 0x05, + OUTPUT(1), 0x02, + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x03, + OUTPUT(1), 0x01, + REPORT_COUNT(1), 0x06, + REPORT_SIZE(1), 0x08, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(2), 0xff, 0x00, + USAGE_PAGE(1), 0x07, + USAGE_MINIMUM(1), 0x00, + USAGE_MAXIMUM(2), 0xff, 0x00, + INPUT(1), 0x00, + END_COLLECTION(0), + + // Mouse + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x02, // Mouse + COLLECTION(1), 0x01, // Application + USAGE(1), 0x01, // Pointer + COLLECTION(1), 0x00, // Physical + REPORT_ID(1), REPORT_ID_MOUSE, + + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x30, // X + USAGE(1), 0x31, // Y + LOGICAL_MINIMUM(1), 0x00, // 0 + LOGICAL_MAXIMUM(2), 0xff, 0x7f, // 32767 + REPORT_SIZE(1), 0x10, + REPORT_COUNT(1), 0x02, + INPUT(1), 0x02, // Data, Variable, Absolute + + USAGE_PAGE(1), 0x01, // Generic Desktop + USAGE(1), 0x38, // scroll + LOGICAL_MINIMUM(1), 0x81, // -127 + LOGICAL_MAXIMUM(1), 0x7f, // 127 + REPORT_SIZE(1), 0x08, + REPORT_COUNT(1), 0x01, + INPUT(1), 0x06, // Data, Variable, Relative + + USAGE_PAGE(1), 0x09, // Buttons + USAGE_MINIMUM(1), 0x01, + USAGE_MAXIMUM(1), 0x03, + LOGICAL_MINIMUM(1), 0x00, // 0 + LOGICAL_MAXIMUM(1), 0x01, // 1 + REPORT_COUNT(1), 0x03, + REPORT_SIZE(1), 0x01, + INPUT(1), 0x02, // Data, Variable, Absolute + REPORT_COUNT(1), 0x01, + REPORT_SIZE(1), 0x05, + INPUT(1), 0x01, // Constant + + END_COLLECTION(0), + END_COLLECTION(0), + + // Media Control + USAGE_PAGE(1), 0x0C, + USAGE(1), 0x01, + COLLECTION(1), 0x01, + REPORT_ID(1), REPORT_ID_VOLUME, + USAGE_PAGE(1), 0x0C, + LOGICAL_MINIMUM(1), 0x00, + LOGICAL_MAXIMUM(1), 0x01, + REPORT_SIZE(1), 0x01, + REPORT_COUNT(1), 0x07, + USAGE(1), 0xB5, // Next Track + USAGE(1), 0xB6, // Previous Track + USAGE(1), 0xB7, // Stop + USAGE(1), 0xCD, // Play / Pause + USAGE(1), 0xE2, // Mute + USAGE(1), 0xE9, // Volume Up + USAGE(1), 0xEA, // Volume Down + INPUT(1), 0x02, // Input (Data, Variable, Absolute) + REPORT_COUNT(1), 0x01, + INPUT(1), 0x01, + END_COLLECTION(0), + }; + reportLength = sizeof(reportDescriptor); + return reportDescriptor; + } + + return NULL; +} + +bool USBMouseKeyboard::EPINT_OUT_callback() { + uint32_t bytesRead = 0; + uint8_t led[65]; + USBDevice::readEP(EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE); + + // we take led[1] because led[0] is the report ID + lock_status = led[1] & 0x07; + + // We activate the endpoint to be able to recceive data + if (!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE)) + return false; + return true; +} + +uint8_t USBMouseKeyboard::lockStatus() { + return lock_status; +} + +bool USBMouseKeyboard::update(int16_t x, int16_t y, uint8_t button, int8_t z) { + switch (mouse_type) { + case REL_MOUSE: + while (x > 127) { + if (!mouseSend(127, 0, button, z)) return false; + x = x - 127; + } + while (x < -128) { + if (!mouseSend(-128, 0, button, z)) return false; + x = x + 128; + } + while (y > 127) { + if (!mouseSend(0, 127, button, z)) return false; + y = y - 127; + } + while (y < -128) { + if (!mouseSend(0, -128, button, z)) return false; + y = y + 128; + } + return mouseSend(x, y, button, z); + case ABS_MOUSE: + HID_REPORT report; + + report.data[0] = REPORT_ID_MOUSE; + report.data[1] = x & 0xff; + report.data[2] = (x >> 8) & 0xff; + report.data[3] = y & 0xff; + report.data[4] = (y >> 8) & 0xff; + report.data[5] = -z; + report.data[6] = button & 0x07; + + report.length = 7; + + return send(&report); + default: + return false; + } +} + +bool USBMouseKeyboard::mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z) { + HID_REPORT report; + report.data[0] = REPORT_ID_MOUSE; + report.data[1] = buttons & 0x07; + report.data[2] = x; + report.data[3] = y; + report.data[4] = -z; // >0 to scroll down, <0 to scroll up + + report.length = 5; + + return send(&report); +} + +bool USBMouseKeyboard::move(int16_t x, int16_t y) { + return update(x, y, button, 0); +} + +bool USBMouseKeyboard::scroll(int8_t z) { + return update(0, 0, button, z); +} + +bool USBMouseKeyboard::doubleClick() { + if (!click(MOUSE_LEFT)) + return false; + wait(0.1); + return click(MOUSE_LEFT); +} + +bool USBMouseKeyboard::click(uint8_t button) { + if (!update(0, 0, button, 0)) + return false; + wait(0.01); + return update(0, 0, 0, 0); +} + +bool USBMouseKeyboard::press(uint8_t button_) { + button = button_ & 0x07; + return update(0, 0, button, 0); +} + +bool USBMouseKeyboard::release(uint8_t button_) { + button = (button & (~button_)) & 0x07; + return update(0, 0, button, 0); +} + +int USBMouseKeyboard::_putc(int c) { + return keyCode(c, keymap[c].modifier); +} + +bool USBMouseKeyboard::keyCode(uint8_t key, uint8_t modifier) { + // Send a simulated keyboard keypress. Returns true if successful. + + HID_REPORT report; + + report.data[0] = REPORT_ID_KEYBOARD; + report.data[1] = modifier; + report.data[2] = 0; + report.data[3] = keymap[key].usage; + report.data[4] = 0; + report.data[5] = 0; + report.data[6] = 0; + report.data[7] = 0; + report.data[8] = 0; + + report.length = 9; + + if (!send(&report)) { + return false; + } + + report.data[1] = 0; + report.data[3] = 0; + + if (!send(&report)) { + return false; + } + + return true; + +} + + +bool USBMouseKeyboard::mediaControl(MEDIA_KEY key) { + HID_REPORT report; + + report.data[0] = REPORT_ID_VOLUME; + report.data[1] = (1 << key) & 0x7f; + + report.length = 2; + + send(&report); + + report.data[0] = REPORT_ID_VOLUME; + report.data[1] = 0; + + report.length = 2; + + return send(&report); +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.h new file mode 100644 index 000000000..1b19b10db --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.h @@ -0,0 +1,220 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBMOUSEKEYBOARD_H +#define USBMOUSEKEYBOARD_H + +#define REPORT_ID_KEYBOARD 1 +#define REPORT_ID_MOUSE 2 +#define REPORT_ID_VOLUME 3 + +#include "USBMouse.h" +#include "USBKeyboard.h" +#include "Stream.h" +#include "USBHID.h" + +/** + * USBMouseKeyboard example + * @code + * + * #include "mbed.h" + * #include "USBMouseKeyboard.h" + * + * USBMouseKeyboard key_mouse; + * + * int main(void) + * { + * while(1) + * { + * key_mouse.move(20, 0); + * key_mouse.printf("Hello From MBED\r\n"); + * wait(1); + * } + * } + * @endcode + * + * + * @code + * + * #include "mbed.h" + * #include "USBMouseKeyboard.h" + * + * USBMouseKeyboard key_mouse(ABS_MOUSE); + * + * int main(void) + * { + * while(1) + * { + * key_mouse.move(X_MAX_ABS/2, Y_MAX_ABS/2); + * key_mouse.printf("Hello from MBED\r\n"); + * wait(1); + * } + * } + * @endcode + */ +class USBMouseKeyboard: public USBHID, public Stream +{ + public: + + /** + * Constructor + * + * @param mouse_type Mouse type: ABS_MOUSE (absolute mouse) or REL_MOUSE (relative mouse) (default: REL_MOUSE) + * @param leds Leds bus: first: NUM_LOCK, second: CAPS_LOCK, third: SCROLL_LOCK + * @param vendor_id Your vendor_id (default: 0x1234) + * @param product_id Your product_id (default: 0x0001) + * @param product_release Your preoduct_release (default: 0x0001) + * + */ + USBMouseKeyboard(MOUSE_TYPE mouse_type = REL_MOUSE, uint16_t vendor_id = 0x0021, uint16_t product_id = 0x0011, uint16_t product_release = 0x0001): + USBHID(0, 0, vendor_id, product_id, product_release, false) + { + lock_status = 0; + button = 0; + this->mouse_type = mouse_type; + connect(); + }; + + /** + * Write a state of the mouse + * + * @param x x-axis position + * @param y y-axis position + * @param buttons buttons state (first bit represents MOUSE_LEFT, second bit MOUSE_RIGHT and third bit MOUSE_MIDDLE) + * @param z wheel state (>0 to scroll down, <0 to scroll up) + * @returns true if there is no error, false otherwise + */ + bool update(int16_t x, int16_t y, uint8_t buttons, int8_t z); + + + /** + * Move the cursor to (x, y) + * + * @param x x-axis position + * @param y y-axis position + * @returns true if there is no error, false otherwise + */ + bool move(int16_t x, int16_t y); + + /** + * Press one or several buttons + * + * @param button button state (ex: press(MOUSE_LEFT)) + * @returns true if there is no error, false otherwise + */ + bool press(uint8_t button); + + /** + * Release one or several buttons + * + * @param button button state (ex: release(MOUSE_LEFT)) + * @returns true if there is no error, false otherwise + */ + bool release(uint8_t button); + + /** + * Double click (MOUSE_LEFT) + * + * @returns true if there is no error, false otherwise + */ + bool doubleClick(); + + /** + * Click + * + * @param button state of the buttons ( ex: clic(MOUSE_LEFT)) + * @returns true if there is no error, false otherwise + */ + bool click(uint8_t button); + + /** + * Scrolling + * + * @param z value of the wheel (>0 to go down, <0 to go up) + * @returns true if there is no error, false otherwise + */ + bool scroll(int8_t z); + + /** + * To send a character defined by a modifier(CTRL, SHIFT, ALT) and the key + * + * @code + * //To send CTRL + s (save) + * keyboard.keyCode('s', KEY_CTRL); + * @endcode + * + * @param modifier bit 0: KEY_CTRL, bit 1: KEY_SHIFT, bit 2: KEY_ALT (default: 0) + * @param key character to send + * @returns true if there is no error, false otherwise + */ + bool keyCode(uint8_t key, uint8_t modifier = 0); + + /** + * Send a character + * + * @param c character to be sent + * @returns true if there is no error, false otherwise + */ + virtual int _putc(int c); + + /** + * Control media keys + * + * @param key media key pressed (KEY_NEXT_TRACK, KEY_PREVIOUS_TRACK, KEY_STOP, KEY_PLAY_PAUSE, KEY_MUTE, KEY_VOLUME_UP, KEY_VOLUME_DOWN) + * @returns true if there is no error, false otherwise + */ + bool mediaControl(MEDIA_KEY key); + + /** + * Read status of lock keys. Useful to switch-on/off leds according to key pressed. Only the first three bits of the result is important: + * - First bit: NUM_LOCK + * - Second bit: CAPS_LOCK + * - Third bit: SCROLL_LOCK + * + * @returns status of lock keys + */ + uint8_t lockStatus(); + + /* + * To define the report descriptor. Warning: this method has to store the length of the report descriptor in reportLength. + * + * @returns pointer to the report descriptor + */ + virtual uint8_t * reportDesc(); + + /* + * Called when a data is received on the OUT endpoint. Useful to switch on LED of LOCK keys + * + * @returns if handle by subclass, return true + */ + virtual bool EPINT_OUT_callback(); + + + private: + bool mouseWrite(int8_t x, int8_t y, uint8_t buttons, int8_t z); + MOUSE_TYPE mouse_type; + uint8_t button; + bool mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z); + + uint8_t lock_status; + + //dummy otherwise it doesn't compile (we must define all methods of an abstract class) + virtual int _getc() { return -1;} +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/MIDIMessage.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/MIDIMessage.h new file mode 100644 index 000000000..9cfcf1363 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/MIDIMessage.h @@ -0,0 +1,276 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef MIDIMESSAGE_H +#define MIDIMESSAGE_H + +#include "mbed.h" + +#define MAX_MIDI_MESSAGE_SIZE 256 // Max message size. SysEx can be up to 65536 but 256 should be fine for most usage + +// MIDI Message Format +// +// [ msg(4) | channel(4) ] [ 0 | n(7) ] [ 0 | m(7) ] +// +// MIDI Data Messages (Channel Specific) +// +// Message msg n m +// --------------------------------------------- +// Note Off 0x8 Key Velocity +// Note On 0x9 Key Velocity +// Polyphonic Aftertouch 0xA Key Pressure +// Control Change 0xB Controller Value +// Program Change 0xC Program - +// Channel Aftertouch 0xD Pressure - +// Pitch Wheel 0xE LSB MSB + +#define CABLE_NUM (0<<4) + +/** A MIDI message container */ +class MIDIMessage { +public: + MIDIMessage() : length(4) {} + + MIDIMessage(uint8_t *buf) : length(4) { + for (int i = 0; i < 4; i++) + data[i] = buf[i]; + } + + // New constructor, buf is a true MIDI message (not USBMidi message) and buf_len true message length. + MIDIMessage(uint8_t *buf, int buf_len) { + length=buf_len+1; + // first byte keeped for retro-compatibility + data[0]=0; + + for (int i = 0; i < buf_len; i++) + data[i+1] = buf[i]; + } + + // create messages + + /** Create a NoteOff message + * @param key Key ID + * @param velocity Key velocity (0-127, default = 127) + * @param channel Key channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage NoteOff(int key, int velocity = 127, int channel = 0) { + MIDIMessage msg; + msg.data[0] = CABLE_NUM | 0x08; + msg.data[1] = 0x80 | (channel & 0x0F); + msg.data[2] = key & 0x7F; + msg.data[3] = velocity & 0x7F; + return msg; + } + + /** Create a NoteOn message + * @param key Key ID + * @param velocity Key velocity (0-127, default = 127) + * @param channel Key channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage NoteOn(int key, int velocity = 127, int channel = 0) { + MIDIMessage msg; + msg.data[0] = CABLE_NUM | 0x09; + msg.data[1] = 0x90 | (channel & 0x0F); + msg.data[2] = key & 0x7F; + msg.data[3] = velocity & 0x7F; + return msg; + } + + /** Create a PolyPhonic Aftertouch message + * @param key Key ID + * @param pressure Aftertouch pressure (0-127) + * @param channel Key channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage PolyphonicAftertouch(int key, int pressure, int channel = 0) { + MIDIMessage msg; + msg.data[0] = CABLE_NUM | 0x0A; + msg.data[1] = 0xA0 | (channel & 0x0F); + msg.data[2] = key & 0x7F; + msg.data[3] = pressure & 0x7F; + return msg; + } + + /** Create a Control Change message + * @param control Controller ID + * @param value Controller value (0-127) + * @param channel Controller channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage ControlChange(int control, int value, int channel = 0) { + MIDIMessage msg; + msg.data[0] = CABLE_NUM | 0x0B; + msg.data[1] = 0xB0 | (channel & 0x0F); + msg.data[2] = control & 0x7F; + msg.data[3] = value & 0x7F; + return msg; + } + + /** Create a Program Change message + * @param program Program ID + * @param channel Channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage ProgramChange(int program, int channel = 0) { + MIDIMessage msg; + msg.data[0] = CABLE_NUM | 0x0C; + msg.data[1] = 0xC0 | (channel & 0x0F); + msg.data[2] = program & 0x7F; + msg.data[3] = 0x00; + return msg; + } + + /** Create a Channel Aftertouch message + * @param pressure Pressure + * @param channel Key channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage ChannelAftertouch(int pressure, int channel = 0) { + MIDIMessage msg; + msg.data[0] = CABLE_NUM | 0x0D; + msg.data[1] = 0xD0 | (channel & 0x0F); + msg.data[2] = pressure & 0x7F; + msg.data[3] = 0x00; + return msg; + } + + /** Create a Pitch Wheel message + * @param pitch Pitch (-8192 - 8191, default = 0) + * @param channel Channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage PitchWheel(int pitch = 0, int channel = 0) { + MIDIMessage msg; + int p = pitch + 8192; // 0 - 16383, 8192 is center + msg.data[0] = CABLE_NUM | 0x0E; + msg.data[1] = 0xE0 | (channel & 0x0F); + msg.data[2] = p & 0x7F; + msg.data[3] = (p >> 7) & 0x7F; + return msg; + } + + /** Create an All Notes Off message + * @param channel Channel (0-15, default 0) + * @returns A MIDIMessage + */ + static MIDIMessage AllNotesOff(int channel = 0) { + return ControlChange(123, 0, channel); + } + + /** Create a SysEx message + * @param data SysEx data (including 0xF0 .. 0xF7) + * @param len SysEx data length + * @returns A MIDIMessage + */ + static MIDIMessage SysEx(uint8_t *data, int len) { + MIDIMessage msg=MIDIMessage(data,len); + return msg; + } + + // decode messages + + /** MIDI Message Types */ + enum MIDIMessageType { + ErrorType, + NoteOffType, + NoteOnType, + PolyphonicAftertouchType, + ControlChangeType, + ProgramChangeType, + ChannelAftertouchType, + PitchWheelType, + AllNotesOffType, + SysExType + }; + + /** Read the message type + * @returns MIDIMessageType + */ + MIDIMessageType type() { + switch((data[1] >> 4) & 0xF) { + case 0x8: return NoteOffType; + case 0x9: return NoteOnType; + case 0xA: return PolyphonicAftertouchType; + case 0xB: + if(controller() < 120) { // standard controllers + return ControlChangeType; + } else if(controller() == 123) { + return AllNotesOffType; + } else { + return ErrorType; // unsupported atm + } + case 0xC: return ProgramChangeType; + case 0xD: return ChannelAftertouchType; + case 0xE: return PitchWheelType; + case 0xF: return SysExType; + default: return ErrorType; + } + } + + /** Read the channel number */ + int channel() { + return (data[1] & 0x0F); + } + + /** Read the key ID */ + int key() { + return (data[2] & 0x7F); + } + + /** Read the velocity */ + int velocity() { + return (data[3] & 0x7F); + } + + /** Read the controller value */ + int value() { + return (data[3] & 0x7F); + } + + /** Read the aftertouch pressure */ + int pressure() { + if(type() == PolyphonicAftertouchType) { + return (data[3] & 0x7F); + } else { + return (data[2] & 0x7F); + } + } + + /** Read the controller number */ + int controller() { + return (data[2] & 0x7F); + } + + /** Read the program number */ + int program() { + return (data[2] & 0x7F); + } + + /** Read the pitch value */ + int pitch() { + int p = ((data[3] & 0x7F) << 7) | (data[2] & 0x7F); + return p - 8192; // 0 - 16383, 8192 is center + } + + uint8_t data[MAX_MIDI_MESSAGE_SIZE+1]; + uint8_t length; +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.cpp new file mode 100644 index 000000000..084574a79 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.cpp @@ -0,0 +1,207 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBMIDI.h" + + +USBMIDI::USBMIDI(uint16_t vendor_id, uint16_t product_id, uint16_t product_release) + : USBDevice(vendor_id, product_id, product_release), cur_data(0), data_end(true) +{ + midi_evt = NULL; + USBDevice::connect(); +} + +// write plain MIDIMessage that will be converted to USBMidi event packet +void USBMIDI::write(MIDIMessage m) { + // first byte keeped for retro-compatibility + for(int p=1; p < m.length; p+=3) { + uint8_t buf[4]; + // Midi message to USBMidi event packet + buf[0]=m.data[1] >> 4; + // SysEx + if(buf[0] == 0xF) { + if((m.length - p) > 3) { + // SysEx start or continue + buf[0]=0x4; + } else { + switch(m.length - p) { + case 1: + // SysEx end with one byte + buf[0]=0x5; + break; + case 2: + // SysEx end with two bytes + buf[0]=0x6; + break; + case 3: + // SysEx end with three bytes + buf[0]=0x7; + break; + } + } + } + buf[1]=m.data[p]; + + if(p+1 < m.length) + buf[2]=m.data[p+1]; + else + buf[2]=0; + + if(p+2 < m.length) + buf[3]=m.data[p+2]; + else + buf[3]=0; + + USBDevice::write(EPBULK_IN, buf, 4, MAX_PACKET_SIZE_EPBULK); + } +} + + +void USBMIDI::attach(void (*fptr)(MIDIMessage)) { + midi_evt = fptr; +} + +bool USBMIDI::EPBULK_OUT_callback() { + uint8_t buf[64]; + uint32_t len; + readEP(EPBULK_OUT, buf, &len, 64); + + if (midi_evt != NULL) { + for (uint32_t i=0; i<len; i+=4) { + uint8_t data_read; + data_end=true; + switch(buf[i]) { + case 0x2: + // Two-bytes System Common Message - undefined in USBMidi 1.0 + data_read=2; + break; + case 0x4: + // SysEx start or continue + data_end=false; + data_read=3; + break; + case 0x5: + // Single-byte System Common Message or SysEx end with one byte + data_read=1; + break; + case 0x6: + // SysEx end with two bytes + data_read=2; + break; + case 0xC: + // Program change + data_read=2; + break; + case 0xD: + // Channel pressure + data_read=2; + break; + case 0xF: + // Single byte + data_read=1; + break; + default: + // Others three-bytes messages + data_read=3; + break; + } + + for(uint8_t j=1;j<data_read+1;j++) { + data[cur_data]=buf[i+j]; + cur_data++; + } + + if(data_end) { + midi_evt(MIDIMessage(data,cur_data)); + cur_data=0; + } + } + } + + // We reactivate the endpoint to receive next characters + readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + return true; +} + +// Called in ISR context +// Set configuration. Return false if the +// configuration is not supported. +bool USBMIDI::USBCallback_setConfiguration(uint8_t configuration) { + if (configuration != DEFAULT_CONFIGURATION) { + return false; + } + + // Configure endpoints > 0 + addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK); + addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + + // We activate the endpoint to be able to receive data + readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + return true; +} + + +uint8_t * USBMIDI::stringIinterfaceDesc() { + static uint8_t stringIinterfaceDescriptor[] = { + 0x0c, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'A',0,'u',0,'d',0,'i',0,'o',0 //bString iInterface - Audio + }; + return stringIinterfaceDescriptor; +} + +uint8_t * USBMIDI::stringIproductDesc() { + static uint8_t stringIproductDescriptor[] = { + 0x16, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'M',0,'b',0,'e',0,'d',0,' ',0,'A',0,'u',0,'d',0,'i',0,'o',0 //bString iProduct - Mbed Audio + }; + return stringIproductDescriptor; +} + + +uint8_t * USBMIDI::configurationDesc() { + static uint8_t configDescriptor[] = { + // configuration descriptor + 0x09, 0x02, 0x65, 0x00, 0x02, 0x01, 0x00, 0xc0, 0x50, + + // The Audio Interface Collection + 0x09, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, // Standard AC Interface Descriptor + 0x09, 0x24, 0x01, 0x00, 0x01, 0x09, 0x00, 0x01, 0x01, // Class-specific AC Interface Descriptor + 0x09, 0x04, 0x01, 0x00, 0x02, 0x01, 0x03, 0x00, 0x00, // MIDIStreaming Interface Descriptors + 0x07, 0x24, 0x01, 0x00, 0x01, 0x41, 0x00, // Class-Specific MS Interface Header Descriptor + + // MIDI IN JACKS + 0x06, 0x24, 0x02, 0x01, 0x01, 0x00, + 0x06, 0x24, 0x02, 0x02, 0x02, 0x00, + + // MIDI OUT JACKS + 0x09, 0x24, 0x03, 0x01, 0x03, 0x01, 0x02, 0x01, 0x00, + 0x09, 0x24, 0x03, 0x02, 0x06, 0x01, 0x01, 0x01, 0x00, + + // OUT endpoint descriptor + 0x09, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x25, 0x01, 0x01, 0x01, + + // IN endpoint descriptor + 0x09, 0x05, 0x82, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x25, 0x01, 0x01, 0x03, + }; + return configDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.h new file mode 100644 index 000000000..cc5be5b7d --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.h @@ -0,0 +1,112 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBMIDI_H +#define USBMIDI_H + +/* These headers are included for child class. */ +#include "USBEndpoints.h" +#include "USBDescriptor.h" +#include "USBDevice_Types.h" + +#include "USBDevice.h" +#include "MIDIMessage.h" + +#define DEFAULT_CONFIGURATION (1) + +/** +* USBMIDI example +* +* @code +* #include "mbed.h" +* #include "USBMIDI.h" +* +* USBMIDI midi; +* +* int main() { +* while (1) { +* for(int i=48; i<83; i++) { // send some messages! +* midi.write(MIDIMessage::NoteOn(i)); +* wait(0.25); +* midi.write(MIDIMessage::NoteOff(i)); +* wait(0.5); +* } +* } +* } +* @endcode +*/ +class USBMIDI: public USBDevice { +public: + + /** + * Constructor + * + * @param vendor_id Your vendor_id + * @param product_id Your product_id + * @param product_release Your preoduct_release + */ + USBMIDI(uint16_t vendor_id = 0x0700, uint16_t product_id = 0x0101, uint16_t product_release = 0x0001); + + /** + * Send a MIDIMessage + * + * @param m The MIDIMessage to send + */ + void write(MIDIMessage m); + + /** + * Attach a callback for when a MIDIEvent is received + * + * @param fptr function pointer + */ + void attach(void (*fptr)(MIDIMessage)); + + +protected: + virtual bool EPBULK_OUT_callback(); + virtual bool USBCallback_setConfiguration(uint8_t configuration); + /* + * Get string product descriptor + * + * @returns pointer to the string product descriptor + */ + virtual uint8_t * stringIproductDesc(); + + /* + * Get string interface descriptor + * + * @returns pointer to the string interface descriptor + */ + virtual uint8_t * stringIinterfaceDesc(); + + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + +private: + uint8_t data[MAX_MIDI_MESSAGE_SIZE+1]; + uint8_t cur_data; + bool data_end; + + void (*midi_evt)(MIDIMessage); +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.cpp new file mode 100644 index 000000000..ee5ad2473 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.cpp @@ -0,0 +1,655 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBMSD.h" + +#define DISK_OK 0x00 +#define NO_INIT 0x01 +#define NO_DISK 0x02 +#define WRITE_PROTECT 0x04 + +#define CBW_Signature 0x43425355 +#define CSW_Signature 0x53425355 + +// SCSI Commands +#define TEST_UNIT_READY 0x00 +#define REQUEST_SENSE 0x03 +#define FORMAT_UNIT 0x04 +#define INQUIRY 0x12 +#define MODE_SELECT6 0x15 +#define MODE_SENSE6 0x1A +#define START_STOP_UNIT 0x1B +#define MEDIA_REMOVAL 0x1E +#define READ_FORMAT_CAPACITIES 0x23 +#define READ_CAPACITY 0x25 +#define READ10 0x28 +#define WRITE10 0x2A +#define VERIFY10 0x2F +#define READ12 0xA8 +#define WRITE12 0xAA +#define MODE_SELECT10 0x55 +#define MODE_SENSE10 0x5A + +// MSC class specific requests +#define MSC_REQUEST_RESET 0xFF +#define MSC_REQUEST_GET_MAX_LUN 0xFE + +#define DEFAULT_CONFIGURATION (1) + +// max packet size +#define MAX_PACKET MAX_PACKET_SIZE_EPBULK + +// CSW Status +enum Status { + CSW_PASSED, + CSW_FAILED, + CSW_ERROR, +}; + + +USBMSD::USBMSD(uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release) { + stage = READ_CBW; + memset((void *)&cbw, 0, sizeof(CBW)); + memset((void *)&csw, 0, sizeof(CSW)); + page = NULL; +} + +USBMSD::~USBMSD() { + disconnect(); +} + + +// Called in ISR context to process a class specific request +bool USBMSD::USBCallback_request(void) { + + bool success = false; + CONTROL_TRANSFER * transfer = getTransferPtr(); + static uint8_t maxLUN[1] = {0}; + + if (transfer->setup.bmRequestType.Type == CLASS_TYPE) { + switch (transfer->setup.bRequest) { + case MSC_REQUEST_RESET: + reset(); + success = true; + break; + case MSC_REQUEST_GET_MAX_LUN: + transfer->remaining = 1; + transfer->ptr = maxLUN; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + default: + break; + } + } + + return success; +} + + +bool USBMSD::connect(bool blocking) { + //disk initialization + if (disk_status() & NO_INIT) { + if (disk_initialize()) { + return false; + } + } + + // get number of blocks + BlockCount = disk_sectors(); + + // get memory size + MemorySize = disk_size(); + + if (BlockCount > 0) { + BlockSize = MemorySize / BlockCount; + if (BlockSize != 0) { + free(page); + page = (uint8_t *)malloc(BlockSize * sizeof(uint8_t)); + if (page == NULL) + return false; + } + } else { + return false; + } + + //connect the device + USBDevice::connect(blocking); + return true; +} + +void USBMSD::disconnect() { + USBDevice::disconnect(); + //De-allocate MSD page size: + free(page); + page = NULL; +} + +void USBMSD::reset() { + stage = READ_CBW; +} + + +// Called in ISR context called when a data is received +bool USBMSD::EPBULK_OUT_callback() { + uint32_t size = 0; + uint8_t buf[MAX_PACKET_SIZE_EPBULK]; + readEP(EPBULK_OUT, buf, &size, MAX_PACKET_SIZE_EPBULK); + switch (stage) { + // the device has to decode the CBW received + case READ_CBW: + CBWDecode(buf, size); + break; + + // the device has to receive data from the host + case PROCESS_CBW: + switch (cbw.CB[0]) { + case WRITE10: + case WRITE12: + memoryWrite(buf, size); + break; + case VERIFY10: + memoryVerify(buf, size); + break; + } + break; + + // an error has occured: stall endpoint and send CSW + default: + stallEndpoint(EPBULK_OUT); + csw.Status = CSW_ERROR; + sendCSW(); + break; + } + + //reactivate readings on the OUT bulk endpoint + readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + return true; +} + +// Called in ISR context when a data has been transferred +bool USBMSD::EPBULK_IN_callback() { + switch (stage) { + + // the device has to send data to the host + case PROCESS_CBW: + switch (cbw.CB[0]) { + case READ10: + case READ12: + memoryRead(); + break; + } + break; + + //the device has to send a CSW + case SEND_CSW: + sendCSW(); + break; + + // the host has received the CSW -> we wait a CBW + case WAIT_CSW: + stage = READ_CBW; + break; + + // an error has occured + default: + stallEndpoint(EPBULK_IN); + sendCSW(); + break; + } + return true; +} + + +void USBMSD::memoryWrite (uint8_t * buf, uint16_t size) { + + if ((addr + size) > MemorySize) { + size = MemorySize - addr; + stage = ERROR; + stallEndpoint(EPBULK_OUT); + } + + // we fill an array in RAM of 1 block before writing it in memory + for (int i = 0; i < size; i++) + page[addr%BlockSize + i] = buf[i]; + + // if the array is filled, write it in memory + if (!((addr + size)%BlockSize)) { + if (!(disk_status() & WRITE_PROTECT)) { + disk_write(page, addr/BlockSize, 1); + } + } + + addr += size; + length -= size; + csw.DataResidue -= size; + + if ((!length) || (stage != PROCESS_CBW)) { + csw.Status = (stage == ERROR) ? CSW_FAILED : CSW_PASSED; + sendCSW(); + } +} + +void USBMSD::memoryVerify (uint8_t * buf, uint16_t size) { + uint32_t n; + + if ((addr + size) > MemorySize) { + size = MemorySize - addr; + stage = ERROR; + stallEndpoint(EPBULK_OUT); + } + + // beginning of a new block -> load a whole block in RAM + if (!(addr%BlockSize)) + disk_read(page, addr/BlockSize, 1); + + // info are in RAM -> no need to re-read memory + for (n = 0; n < size; n++) { + if (page[addr%BlockSize + n] != buf[n]) { + memOK = false; + break; + } + } + + addr += size; + length -= size; + csw.DataResidue -= size; + + if ( !length || (stage != PROCESS_CBW)) { + csw.Status = (memOK && (stage == PROCESS_CBW)) ? CSW_PASSED : CSW_FAILED; + sendCSW(); + } +} + + +bool USBMSD::inquiryRequest (void) { + uint8_t inquiry[] = { 0x00, 0x80, 0x00, 0x01, + 36 - 4, 0x80, 0x00, 0x00, + 'M', 'B', 'E', 'D', '.', 'O', 'R', 'G', + 'M', 'B', 'E', 'D', ' ', 'U', 'S', 'B', ' ', 'D', 'I', 'S', 'K', ' ', ' ', ' ', + '1', '.', '0', ' ', + }; + if (!write(inquiry, sizeof(inquiry))) { + return false; + } + return true; +} + + +bool USBMSD::readFormatCapacity() { + uint8_t capacity[] = { 0x00, 0x00, 0x00, 0x08, + (uint8_t)((BlockCount >> 24) & 0xff), + (uint8_t)((BlockCount >> 16) & 0xff), + (uint8_t)((BlockCount >> 8) & 0xff), + (uint8_t)((BlockCount >> 0) & 0xff), + + 0x02, + (uint8_t)((BlockSize >> 16) & 0xff), + (uint8_t)((BlockSize >> 8) & 0xff), + (uint8_t)((BlockSize >> 0) & 0xff), + }; + if (!write(capacity, sizeof(capacity))) { + return false; + } + return true; +} + + +bool USBMSD::readCapacity (void) { + uint8_t capacity[] = { + (uint8_t)(((BlockCount - 1) >> 24) & 0xff), + (uint8_t)(((BlockCount - 1) >> 16) & 0xff), + (uint8_t)(((BlockCount - 1) >> 8) & 0xff), + (uint8_t)(((BlockCount - 1) >> 0) & 0xff), + + (uint8_t)((BlockSize >> 24) & 0xff), + (uint8_t)((BlockSize >> 16) & 0xff), + (uint8_t)((BlockSize >> 8) & 0xff), + (uint8_t)((BlockSize >> 0) & 0xff), + }; + if (!write(capacity, sizeof(capacity))) { + return false; + } + return true; +} + +bool USBMSD::write (uint8_t * buf, uint16_t size) { + + if (size >= cbw.DataLength) { + size = cbw.DataLength; + } + stage = SEND_CSW; + + if (!writeNB(EPBULK_IN, buf, size, MAX_PACKET_SIZE_EPBULK)) { + return false; + } + + csw.DataResidue -= size; + csw.Status = CSW_PASSED; + return true; +} + + +bool USBMSD::modeSense6 (void) { + uint8_t sense6[] = { 0x03, 0x00, 0x00, 0x00 }; + if (!write(sense6, sizeof(sense6))) { + return false; + } + return true; +} + +void USBMSD::sendCSW() { + csw.Signature = CSW_Signature; + writeNB(EPBULK_IN, (uint8_t *)&csw, sizeof(CSW), MAX_PACKET_SIZE_EPBULK); + stage = WAIT_CSW; +} + +bool USBMSD::requestSense (void) { + uint8_t request_sense[] = { + 0x70, + 0x00, + 0x05, // Sense Key: illegal request + 0x00, + 0x00, + 0x00, + 0x00, + 0x0A, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x01, + 0x00, + 0x00, + 0x00, + 0x00, + }; + + if (!write(request_sense, sizeof(request_sense))) { + return false; + } + + return true; +} + +void USBMSD::fail() { + csw.Status = CSW_FAILED; + sendCSW(); +} + + +void USBMSD::CBWDecode(uint8_t * buf, uint16_t size) { + if (size == sizeof(cbw)) { + memcpy((uint8_t *)&cbw, buf, size); + if (cbw.Signature == CBW_Signature) { + csw.Tag = cbw.Tag; + csw.DataResidue = cbw.DataLength; + if ((cbw.CBLength < 1) || (cbw.CBLength > 16) ) { + fail(); + } else { + switch (cbw.CB[0]) { + case TEST_UNIT_READY: + testUnitReady(); + break; + case REQUEST_SENSE: + requestSense(); + break; + case INQUIRY: + inquiryRequest(); + break; + case MODE_SENSE6: + modeSense6(); + break; + case READ_FORMAT_CAPACITIES: + readFormatCapacity(); + break; + case READ_CAPACITY: + readCapacity(); + break; + case READ10: + case READ12: + if (infoTransfer()) { + if ((cbw.Flags & 0x80)) { + stage = PROCESS_CBW; + memoryRead(); + } else { + stallEndpoint(EPBULK_OUT); + csw.Status = CSW_ERROR; + sendCSW(); + } + } + break; + case WRITE10: + case WRITE12: + if (infoTransfer()) { + if (!(cbw.Flags & 0x80)) { + stage = PROCESS_CBW; + } else { + stallEndpoint(EPBULK_IN); + csw.Status = CSW_ERROR; + sendCSW(); + } + } + break; + case VERIFY10: + if (!(cbw.CB[1] & 0x02)) { + csw.Status = CSW_PASSED; + sendCSW(); + break; + } + if (infoTransfer()) { + if (!(cbw.Flags & 0x80)) { + stage = PROCESS_CBW; + memOK = true; + } else { + stallEndpoint(EPBULK_IN); + csw.Status = CSW_ERROR; + sendCSW(); + } + } + break; + case MEDIA_REMOVAL: + csw.Status = CSW_PASSED; + sendCSW(); + break; + default: + fail(); + break; + } + } + } + } +} + +void USBMSD::testUnitReady (void) { + + if (cbw.DataLength != 0) { + if ((cbw.Flags & 0x80) != 0) { + stallEndpoint(EPBULK_IN); + } else { + stallEndpoint(EPBULK_OUT); + } + } + + csw.Status = CSW_PASSED; + sendCSW(); +} + + +void USBMSD::memoryRead (void) { + uint32_t n; + + n = (length > MAX_PACKET) ? MAX_PACKET : length; + + if ((addr + n) > MemorySize) { + n = MemorySize - addr; + stage = ERROR; + } + + // we read an entire block + if (!(addr%BlockSize)) + disk_read(page, addr/BlockSize, 1); + + // write data which are in RAM + writeNB(EPBULK_IN, &page[addr%BlockSize], n, MAX_PACKET_SIZE_EPBULK); + + addr += n; + length -= n; + + csw.DataResidue -= n; + + if ( !length || (stage != PROCESS_CBW)) { + csw.Status = (stage == PROCESS_CBW) ? CSW_PASSED : CSW_FAILED; + stage = (stage == PROCESS_CBW) ? SEND_CSW : stage; + } +} + + +bool USBMSD::infoTransfer (void) { + uint32_t n; + + // Logical Block Address of First Block + n = (cbw.CB[2] << 24) | (cbw.CB[3] << 16) | (cbw.CB[4] << 8) | (cbw.CB[5] << 0); + + addr = n * BlockSize; + + // Number of Blocks to transfer + switch (cbw.CB[0]) { + case READ10: + case WRITE10: + case VERIFY10: + n = (cbw.CB[7] << 8) | (cbw.CB[8] << 0); + break; + + case READ12: + case WRITE12: + n = (cbw.CB[6] << 24) | (cbw.CB[7] << 16) | (cbw.CB[8] << 8) | (cbw.CB[9] << 0); + break; + } + + length = n * BlockSize; + + if (!cbw.DataLength) { // host requests no data + csw.Status = CSW_FAILED; + sendCSW(); + return false; + } + + if (cbw.DataLength != length) { + if ((cbw.Flags & 0x80) != 0) { + stallEndpoint(EPBULK_IN); + } else { + stallEndpoint(EPBULK_OUT); + } + + csw.Status = CSW_FAILED; + sendCSW(); + return false; + } + + return true; +} + + + + + +// Called in ISR context +// Set configuration. Return false if the +// configuration is not supported. +bool USBMSD::USBCallback_setConfiguration(uint8_t configuration) { + if (configuration != DEFAULT_CONFIGURATION) { + return false; + } + + // Configure endpoints > 0 + addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK); + addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + + //activate readings + readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + return true; +} + + +uint8_t * USBMSD::stringIinterfaceDesc() { + static uint8_t stringIinterfaceDescriptor[] = { + 0x08, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'M',0,'S',0,'D',0 //bString iInterface - MSD + }; + return stringIinterfaceDescriptor; +} + +uint8_t * USBMSD::stringIproductDesc() { + static uint8_t stringIproductDescriptor[] = { + 0x12, //bLength + STRING_DESCRIPTOR, //bDescriptorType 0x03 + 'M',0,'b',0,'e',0,'d',0,' ',0,'M',0,'S',0,'D',0 //bString iProduct - Mbed Audio + }; + return stringIproductDescriptor; +} + + +uint8_t * USBMSD::configurationDesc() { + static uint8_t configDescriptor[] = { + + // Configuration 1 + 9, // bLength + 2, // bDescriptorType + LSB(9 + 9 + 7 + 7), // wTotalLength + MSB(9 + 9 + 7 + 7), + 0x01, // bNumInterfaces + 0x01, // bConfigurationValue: 0x01 is used to select this configuration + 0x00, // iConfiguration: no string to describe this configuration + 0xC0, // bmAttributes + 100, // bMaxPower, device power consumption is 100 mA + + // Interface 0, Alternate Setting 0, MSC Class + 9, // bLength + 4, // bDescriptorType + 0x00, // bInterfaceNumber + 0x00, // bAlternateSetting + 0x02, // bNumEndpoints + 0x08, // bInterfaceClass + 0x06, // bInterfaceSubClass + 0x50, // bInterfaceProtocol + 0x04, // iInterface + + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + 7, // bLength + 5, // bDescriptorType + PHY_TO_DESC(EPBULK_IN), // bEndpointAddress + 0x02, // bmAttributes (0x02=bulk) + LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB) + 0, // bInterval + + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + 7, // bLength + 5, // bDescriptorType + PHY_TO_DESC(EPBULK_OUT), // bEndpointAddress + 0x02, // bmAttributes (0x02=bulk) + LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB) + 0 // bInterval + }; + return configDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.h new file mode 100644 index 000000000..ff750026c --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.h @@ -0,0 +1,251 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + + +#ifndef USBMSD_H +#define USBMSD_H + +/* These headers are included for child class. */ +#include "USBEndpoints.h" +#include "USBDescriptor.h" +#include "USBDevice_Types.h" + +#include "USBDevice.h" + +/** + * USBMSD class: generic class in order to use all kinds of blocks storage chip + * + * Introduction + * + * The USBMSD implements the MSD protocol. It permits to access a memory chip (flash, sdcard,...) + * from a computer over USB. But this class doesn't work standalone, you need to subclass this class + * and define virtual functions which are called in USBMSD. + * + * How to use this class with your chip ? + * + * You have to inherit and define some pure virtual functions (mandatory step): + * - virtual int disk_read(char * data, int block): function to read a block + * - virtual int disk_write(const char * data, int block): function to write a block + * - virtual int disk_initialize(): function to initialize the memory + * - virtual int disk_sectors(): return the number of blocks + * - virtual int disk_size(): return the memory size + * - virtual int disk_status(): return the status of the storage chip (0: OK, 1: not initialized, 2: no medium in the drive, 4: write protection) + * + * All functions names are compatible with the fat filesystem library. So you can imagine using your own class with + * USBMSD and the fat filesystem library in the same program. Just be careful because there are two different parts which + * will access the sd card. You can do a master/slave system using the disk_status method. + * + * Once these functions defined, you can call connect() (at the end of the constructor of your class for instance) + * of USBMSD to connect your mass storage device. connect() will first call disk_status() to test the status of the disk. + * If disk_status() returns 1 (disk not initialized), then disk_initialize() is called. After this step, connect() will collect information + * such as the number of blocks and the memory size. + */ +class USBMSD: public USBDevice { +public: + + /** + * Constructor + * + * @param vendor_id Your vendor_id + * @param product_id Your product_id + * @param product_release Your preoduct_release + */ + USBMSD(uint16_t vendor_id = 0x0703, uint16_t product_id = 0x0104, uint16_t product_release = 0x0001); + + /** + * Connect the USB MSD device. Establish disk initialization before really connect the device. + * + * @param blocking if not configured + * @returns true if successful + */ + bool connect(bool blocking = true); + + /** + * Disconnect the USB MSD device. + */ + void disconnect(); + + /** + * Destructor + */ + ~USBMSD(); + +protected: + + /* + * read one or more blocks on a storage chip + * + * @param data pointer where will be stored read data + * @param block starting block number + * @param count number of blocks to read + * @returns 0 if successful + */ + virtual int disk_read(uint8_t* data, uint64_t block, uint8_t count) = 0; + + /* + * write one or more blocks on a storage chip + * + * @param data data to write + * @param block starting block number + * @param count number of blocks to write + * @returns 0 if successful + */ + virtual int disk_write(const uint8_t* data, uint64_t block, uint8_t count) = 0; + + /* + * Disk initilization + */ + virtual int disk_initialize() = 0; + + /* + * Return the number of blocks + * + * @returns number of blocks + */ + virtual uint64_t disk_sectors() = 0; + + /* + * Return memory size + * + * @returns memory size + */ + virtual uint64_t disk_size() = 0; + + + /* + * To check the status of the storage chip + * + * @returns status: 0: OK, 1: disk not initialized, 2: no medium in the drive, 4: write protected + */ + virtual int disk_status() = 0; + + /* + * Get string product descriptor + * + * @returns pointer to the string product descriptor + */ + virtual uint8_t * stringIproductDesc(); + + /* + * Get string interface descriptor + * + * @returns pointer to the string interface descriptor + */ + virtual uint8_t * stringIinterfaceDesc(); + + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + + /* + * Callback called when a packet is received + */ + virtual bool EPBULK_OUT_callback(); + + /* + * Callback called when a packet has been sent + */ + virtual bool EPBULK_IN_callback(); + + /* + * Set configuration of device. Add endpoints + */ + virtual bool USBCallback_setConfiguration(uint8_t configuration); + + /* + * Callback called to process class specific requests + */ + virtual bool USBCallback_request(); + + +private: + + // MSC Bulk-only Stage + enum Stage { + READ_CBW, // wait a CBW + ERROR, // error + PROCESS_CBW, // process a CBW request + SEND_CSW, // send a CSW + WAIT_CSW, // wait that a CSW has been effectively sent + }; + + // Bulk-only CBW + typedef struct { + uint32_t Signature; + uint32_t Tag; + uint32_t DataLength; + uint8_t Flags; + uint8_t LUN; + uint8_t CBLength; + uint8_t CB[16]; + } PACKED CBW; + + // Bulk-only CSW + typedef struct { + uint32_t Signature; + uint32_t Tag; + uint32_t DataResidue; + uint8_t Status; + } PACKED CSW; + + //state of the bulk-only state machine + Stage stage; + + // current CBW + CBW cbw; + + // CSW which will be sent + CSW csw; + + // addr where will be read or written data + uint32_t addr; + + // length of a reading or writing + uint32_t length; + + // memory OK (after a memoryVerify) + bool memOK; + + // cache in RAM before writing in memory. Useful also to read a block. + uint8_t * page; + + int BlockSize; + uint64_t MemorySize; + uint64_t BlockCount; + + void CBWDecode(uint8_t * buf, uint16_t size); + void sendCSW (void); + bool inquiryRequest (void); + bool write (uint8_t * buf, uint16_t size); + bool readFormatCapacity(); + bool readCapacity (void); + bool infoTransfer (void); + void memoryRead (void); + bool modeSense6 (void); + void testUnitReady (void); + bool requestSense (void); + void memoryVerify (uint8_t * buf, uint16_t size); + void memoryWrite (uint8_t * buf, uint16_t size); + void reset(); + void fail(); +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/CircBuffer.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/CircBuffer.h new file mode 100644 index 000000000..ea46bdfe6 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/CircBuffer.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef CIRCBUFFER_H +#define CIRCBUFFER_H + +template <class T, int Size> +class CircBuffer { +public: + CircBuffer():write(0), read(0){} + bool isFull() { + return ((write + 1) % size == read); + }; + + bool isEmpty() { + return (read == write); + }; + + void queue(T k) { + if (isFull()) { + read++; + read %= size; + } + buf[write++] = k; + write %= size; + } + + uint16_t available() { + return (write >= read) ? write - read : size - read + write; + }; + + bool dequeue(T * c) { + bool empty = isEmpty(); + if (!empty) { + *c = buf[read++]; + read %= size; + } + return(!empty); + }; + +private: + volatile uint16_t write; + volatile uint16_t read; + static const int size = Size+1; //a modern optimizer should be able to remove this so it uses no ram. + T buf[Size]; +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.cpp new file mode 100644 index 000000000..aa55541f3 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.cpp @@ -0,0 +1,286 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBCDC.h" + +static uint8_t cdc_line_coding[7]= {0x80, 0x25, 0x00, 0x00, 0x00, 0x00, 0x08}; + +#define DEFAULT_CONFIGURATION (1) + +#define CDC_SET_LINE_CODING 0x20 +#define CDC_GET_LINE_CODING 0x21 +#define CDC_SET_CONTROL_LINE_STATE 0x22 + +// Control Line State bits +#define CLS_DTR (1 << 0) +#define CLS_RTS (1 << 1) + +#define MAX_CDC_REPORT_SIZE MAX_PACKET_SIZE_EPBULK + +USBCDC::USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect_blocking): USBDevice(vendor_id, product_id, product_release) { + terminal_connected = false; + USBDevice::connect(connect_blocking); +} + +bool USBCDC::USBCallback_request(void) { + /* Called in ISR context */ + + bool success = false; + CONTROL_TRANSFER * transfer = getTransferPtr(); + + /* Process class-specific requests */ + + if (transfer->setup.bmRequestType.Type == CLASS_TYPE) { + switch (transfer->setup.bRequest) { + case CDC_GET_LINE_CODING: + transfer->remaining = 7; + transfer->ptr = cdc_line_coding; + transfer->direction = DEVICE_TO_HOST; + success = true; + break; + case CDC_SET_LINE_CODING: + transfer->remaining = 7; + transfer->notify = true; + success = true; + break; + case CDC_SET_CONTROL_LINE_STATE: + if (transfer->setup.wValue & CLS_DTR) { + terminal_connected = true; + } else { + terminal_connected = false; + } + success = true; + break; + default: + break; + } + } + + return success; +} + +void USBCDC::USBCallback_requestCompleted(uint8_t *buf, uint32_t length) { + // Request of setting line coding has 7 bytes + if (length != 7) { + return; + } + + CONTROL_TRANSFER * transfer = getTransferPtr(); + + /* Process class-specific requests */ + if (transfer->setup.bmRequestType.Type == CLASS_TYPE) { + if (transfer->setup.bRequest == CDC_SET_LINE_CODING) { + if (memcmp(cdc_line_coding, buf, 7)) { + memcpy(cdc_line_coding, buf, 7); + + int baud = buf[0] + (buf[1] << 8) + + (buf[2] << 16) + (buf[3] << 24); + int stop = buf[4]; + int bits = buf[6]; + int parity = buf[5]; + + lineCodingChanged(baud, bits, parity, stop); + } + } + } +} + +// Called in ISR context +// Set configuration. Return false if the +// configuration is not supported. +bool USBCDC::USBCallback_setConfiguration(uint8_t configuration) { + if (configuration != DEFAULT_CONFIGURATION) { + return false; + } + + // Configure endpoints > 0 + addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT); + addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK); + addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + + // We activate the endpoint to be able to recceive data + readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK); + return true; +} + +bool USBCDC::send(uint8_t * buffer, uint32_t size) { + return USBDevice::write(EPBULK_IN, buffer, size, MAX_CDC_REPORT_SIZE); +} + +bool USBCDC::readEP(uint8_t * buffer, uint32_t * size) { + if (!USBDevice::readEP(EPBULK_OUT, buffer, size, MAX_CDC_REPORT_SIZE)) + return false; + if (!readStart(EPBULK_OUT, MAX_CDC_REPORT_SIZE)) + return false; + return true; +} + +bool USBCDC::readEP_NB(uint8_t * buffer, uint32_t * size) { + if (!USBDevice::readEP_NB(EPBULK_OUT, buffer, size, MAX_CDC_REPORT_SIZE)) + return false; + if (!readStart(EPBULK_OUT, MAX_CDC_REPORT_SIZE)) + return false; + return true; +} + + +uint8_t * USBCDC::deviceDesc() { + static uint8_t deviceDescriptor[] = { + 18, // bLength + 1, // bDescriptorType + 0x10, 0x01, // bcdUSB + 2, // bDeviceClass + 0, // bDeviceSubClass + 0, // bDeviceProtocol + MAX_PACKET_SIZE_EP0, // bMaxPacketSize0 + (uint8_t)(LSB(VENDOR_ID)), (uint8_t)(MSB(VENDOR_ID)), // idVendor + (uint8_t)(LSB(PRODUCT_ID)), (uint8_t)(MSB(PRODUCT_ID)),// idProduct + 0x00, 0x01, // bcdDevice + 1, // iManufacturer + 2, // iProduct + 3, // iSerialNumber + 1 // bNumConfigurations + }; + return deviceDescriptor; +} + +uint8_t * USBCDC::stringIinterfaceDesc() { + static uint8_t stringIinterfaceDescriptor[] = { + 0x08, + STRING_DESCRIPTOR, + 'C',0,'D',0,'C',0, + }; + return stringIinterfaceDescriptor; +} + +uint8_t * USBCDC::stringIproductDesc() { + static uint8_t stringIproductDescriptor[] = { + 0x16, + STRING_DESCRIPTOR, + 'C',0,'D',0,'C',0,' ',0,'D',0,'E',0,'V',0,'I',0,'C',0,'E',0 + }; + return stringIproductDescriptor; +} + + +#define CONFIG1_DESC_SIZE (9+8+9+5+5+4+5+7+9+7+7) + +uint8_t * USBCDC::configurationDesc() { + static uint8_t configDescriptor[] = { + // configuration descriptor + 9, // bLength + 2, // bDescriptorType + LSB(CONFIG1_DESC_SIZE), // wTotalLength + MSB(CONFIG1_DESC_SIZE), + 2, // bNumInterfaces + 1, // bConfigurationValue + 0, // iConfiguration + 0x80, // bmAttributes + 50, // bMaxPower + + // IAD to associate the two CDC interfaces + 0x08, // bLength + 0x0b, // bDescriptorType + 0x00, // bFirstInterface + 0x02, // bInterfaceCount + 0x02, // bFunctionClass + 0x02, // bFunctionSubClass + 0, // bFunctionProtocol + 0, // iFunction + + // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12 + 9, // bLength + 4, // bDescriptorType + 0, // bInterfaceNumber + 0, // bAlternateSetting + 1, // bNumEndpoints + 0x02, // bInterfaceClass + 0x02, // bInterfaceSubClass + 0x01, // bInterfaceProtocol + 0, // iInterface + + // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26 + 5, // bFunctionLength + 0x24, // bDescriptorType + 0x00, // bDescriptorSubtype + 0x10, 0x01, // bcdCDC + + // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27 + 5, // bFunctionLength + 0x24, // bDescriptorType + 0x01, // bDescriptorSubtype + 0x03, // bmCapabilities + 1, // bDataInterface + + // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28 + 4, // bFunctionLength + 0x24, // bDescriptorType + 0x02, // bDescriptorSubtype + 0x06, // bmCapabilities + + // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33 + 5, // bFunctionLength + 0x24, // bDescriptorType + 0x06, // bDescriptorSubtype + 0, // bMasterInterface + 1, // bSlaveInterface0 + + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPINT_IN), // bEndpointAddress + E_INTERRUPT, // bmAttributes (0x03=intr) + LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB) + 16, // bInterval + + + + + // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12 + 9, // bLength + 4, // bDescriptorType + 1, // bInterfaceNumber + 0, // bAlternateSetting + 2, // bNumEndpoints + 0x0A, // bInterfaceClass + 0x00, // bInterfaceSubClass + 0x00, // bInterfaceProtocol + 0, // iInterface + + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPBULK_IN), // bEndpointAddress + E_BULK, // bmAttributes (0x02=bulk) + LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB) + 0, // bInterval + + // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13 + ENDPOINT_DESCRIPTOR_LENGTH, // bLength + ENDPOINT_DESCRIPTOR, // bDescriptorType + PHY_TO_DESC(EPBULK_OUT), // bEndpointAddress + E_BULK, // bmAttributes (0x02=bulk) + LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB) + MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB) + 0 // bInterval + }; + return configDescriptor; +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.h new file mode 100644 index 000000000..33c6b0a02 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.h @@ -0,0 +1,123 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBCDC_H +#define USBCDC_H + +/* These headers are included for child class. */ +#include "USBEndpoints.h" +#include "USBDescriptor.h" +#include "USBDevice_Types.h" + +#include "USBDevice.h" + +class USBCDC: public USBDevice { +public: + + /* + * Constructor + * + * @param vendor_id Your vendor_id + * @param product_id Your product_id + * @param product_release Your preoduct_release + * @param connect_blocking define if the connection must be blocked if USB not plugged in + */ + USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect_blocking); + +protected: + + /* + * Get device descriptor. Warning: this method has to store the length of the report descriptor in reportLength. + * + * @returns pointer to the device descriptor + */ + virtual uint8_t * deviceDesc(); + + /* + * Get string product descriptor + * + * @returns pointer to the string product descriptor + */ + virtual uint8_t * stringIproductDesc(); + + /* + * Get string interface descriptor + * + * @returns pointer to the string interface descriptor + */ + virtual uint8_t * stringIinterfaceDesc(); + + /* + * Get configuration descriptor + * + * @returns pointer to the configuration descriptor + */ + virtual uint8_t * configurationDesc(); + + /* + * Send a buffer + * + * @param endpoint endpoint which will be sent the buffer + * @param buffer buffer to be sent + * @param size length of the buffer + * @returns true if successful + */ + bool send(uint8_t * buffer, uint32_t size); + + /* + * Read a buffer from a certain endpoint. Warning: blocking + * + * @param endpoint endpoint to read + * @param buffer buffer where will be stored bytes + * @param size the number of bytes read will be stored in *size + * @param maxSize the maximum length that can be read + * @returns true if successful + */ + bool readEP(uint8_t * buffer, uint32_t * size); + + /* + * Read a buffer from a certain endpoint. Warning: non blocking + * + * @param endpoint endpoint to read + * @param buffer buffer where will be stored bytes + * @param size the number of bytes read will be stored in *size + * @param maxSize the maximum length that can be read + * @returns true if successful + */ + bool readEP_NB(uint8_t * buffer, uint32_t * size); + + /* + * Called by USBCallback_requestCompleted when CDC line coding is changed + * Warning: Called in ISR + * + * @param baud The baud rate + * @param bits The number of bits in a word (5-8) + * @param parity The parity + * @param stop The number of stop bits (1 or 2) + */ + virtual void lineCodingChanged(int baud, int bits, int parity, int stop) {}; + +protected: + virtual bool USBCallback_request(); + virtual void USBCallback_requestCompleted(uint8_t *buf, uint32_t length); + virtual bool USBCallback_setConfiguration(uint8_t configuration); + volatile bool terminal_connected; + +}; + +#endif diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.cpp b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.cpp new file mode 100644 index 000000000..4dc28b9e3 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.cpp @@ -0,0 +1,67 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include "stdint.h" +#include "USBSerial.h" + +int USBSerial::_putc(int c) { + if (!terminal_connected) + return 0; + send((uint8_t *)&c, 1); + return 1; +} + +int USBSerial::_getc() { + uint8_t c = 0; + while (buf.isEmpty()); + buf.dequeue(&c); + return c; +} + + +bool USBSerial::writeBlock(uint8_t * buf, uint16_t size) { + if(size > MAX_PACKET_SIZE_EPBULK) { + return false; + } + if(!send(buf, size)) { + return false; + } + return true; +} + + + +bool USBSerial::EPBULK_OUT_callback() { + uint8_t c[65]; + uint32_t size = 0; + + //we read the packet received and put it on the circular buffer + readEP(c, &size); + for (uint32_t i = 0; i < size; i++) { + buf.queue(c[i]); + } + + //call a potential handler + rx.call(); + + return true; +} + +uint8_t USBSerial::available() { + return buf.available(); +} diff --git a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.h b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.h new file mode 100644 index 000000000..164cf9bc7 --- /dev/null +++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.h @@ -0,0 +1,161 @@ +/* Copyright (c) 2010-2011 mbed.org, MIT License +* +* Permission is hereby granted, free of charge, to any person obtaining a copy of this software +* and associated documentation files (the "Software"), to deal in the Software without +* restriction, including without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in all copies or +* substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING +* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef USBSERIAL_H +#define USBSERIAL_H + +#include "USBCDC.h" +#include "Stream.h" +#include "CircBuffer.h" + + +/** +* USBSerial example +* +* @code +* #include "mbed.h" +* #include "USBSerial.h" +* +* //Virtual serial port over USB +* USBSerial serial; +* +* int main(void) { +* +* while(1) +* { +* serial.printf("I am a virtual serial port\n"); +* wait(1); +* } +* } +* @endcode +*/ +class USBSerial: public USBCDC, public Stream { +public: + + /** + * Constructor + * + * @param vendor_id Your vendor_id (default: 0x1f00) + * @param product_id Your product_id (default: 0x2012) + * @param product_release Your preoduct_release (default: 0x0001) + * @param connect_blocking define if the connection must be blocked if USB not plugged in + * + */ + USBSerial(uint16_t vendor_id = 0x1f00, uint16_t product_id = 0x2012, uint16_t product_release = 0x0001, bool connect_blocking = true): USBCDC(vendor_id, product_id, product_release, connect_blocking){ + settingsChangedCallback = 0; + }; + + + /** + * Send a character. You can use puts, printf. + * + * @param c character to be sent + * @returns true if there is no error, false otherwise + */ + virtual int _putc(int c); + + /** + * Read a character: blocking + * + * @returns character read + */ + virtual int _getc(); + + /** + * Check the number of bytes available. + * + * @returns the number of bytes available + */ + uint8_t available(); + + /** Determine if there is a character available to read + * + * @returns + * 1 if there is a character available to read, + * 0 otherwise + */ + int readable() { return available() ? 1 : 0; } + + /** Determine if there is space available to write a character + * + * @returns + * 1 if there is space to write a character, + * 0 otherwise + */ + int writeable() { return 1; } // always return 1, for write operation is blocking + + /** + * Write a block of data. + * + * For more efficiency, a block of size 64 (maximum size of a bulk endpoint) has to be written. + * + * @param buf pointer on data which will be written + * @param size size of the buffer. The maximum size of a block is limited by the size of the endpoint (64 bytes) + * + * @returns true if successfull + */ + bool writeBlock(uint8_t * buf, uint16_t size); + + /** + * Attach a member function to call when a packet is received. + * + * @param tptr pointer to the object to call the member function on + * @param mptr pointer to the member function to be called + */ + template<typename T> + void attach(T* tptr, void (T::*mptr)(void)) { + if((mptr != NULL) && (tptr != NULL)) { + rx.attach(tptr, mptr); + } + } + + /** + * Attach a callback called when a packet is received + * + * @param fptr function pointer + */ + void attach(void (*fptr)(void)) { + if(fptr != NULL) { + rx.attach(fptr); + } + } + + /** + * Attach a callback to call when serial's settings are changed. + * + * @param fptr function pointer + */ + void attach(void (*fptr)(int baud, int bits, int parity, int stop)) { + settingsChangedCallback = fptr; + } + +protected: + virtual bool EPBULK_OUT_callback(); + virtual void lineCodingChanged(int baud, int bits, int parity, int stop){ + if (settingsChangedCallback) { + settingsChangedCallback(baud, bits, parity, stop); + } + } + +private: + FunctionPointer rx; + CircBuffer<uint8_t,128> buf; + void (*settingsChangedCallback)(int baud, int bits, int parity, int stop); +}; + +#endif |