drashna/qmk_firmware
1
0
Fork 0
Code Activity Actions

Squashed 'tmk_core/' changes from 7967731..b9e0ea0

Browse source 
b9e0ea0 Merge commit '7fa9d8bdea3773d1195b04d98fcf27cf48ddd81d' as 'tool/mbed/mbed-sdk'
7fa9d8b Squashed 'tool/mbed/mbed-sdk/' content from commit 7c21ce5

git-subtree-dir: tmk_core
git-subtree-split: b9e0ea08cb940de20b3610ecdda18e9d8cd7c552
This commit is contained in:
Jun Wako 2015-04-24 16:26:14 +09:00
parent a20ef7052c
commit 1fe4406f37
4198 changed files with 2016457 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

618
tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.cpp Normal file
View file

@ -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;
}

287
tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.h Normal file
View file

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

97
tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio_Types.h Normal file
View file

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

365
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h Normal file
View file

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

143
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h Normal file
View file

@ -0,0 +1,143 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb_function.h
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Description : RZ/A1H R7S72100 USB Sample Program
*******************************************************************************/
#ifndef USB_FUNCTION_H
#define USB_FUNCTION_H
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "r_typedefs.h"
#include "iodefine.h"
#include "rza_io_regrw.h"
/*******************************************************************************
Macro definitions
*******************************************************************************/
#define USB_FUNCTION_ALT_NO (255)
#define USB_FUNCTION_ALT_SET (0xff)
#define USB_FUNCTION_BITUPLLE (0x0002u)
#define USB_FUNCTION_BITUCKSEL (0x0004u)
#define USB_FUNCTION_BITBWAIT (0x003fu)
#define USB_FUNCTION_BUSWAIT_02 (0x0000u)
#define USB_FUNCTION_BUSWAIT_03 (0x0001u)
#define USB_FUNCTION_BUSWAIT_04 (0x0002u)
#define USB_FUNCTION_BUSWAIT_05 (0x0003u)
#define USB_FUNCTION_BUSWAIT_06 (0x0004u)
#define USB_FUNCTION_BUSWAIT_07 (0x0005u)
#define USB_FUNCTION_BUSWAIT_08 (0x0006u)
#define USB_FUNCTION_BUSWAIT_09 (0x0007u)
#define USB_FUNCTION_BUSWAIT_10 (0x0008u)
#define USB_FUNCTION_BUSWAIT_11 (0x0009u)
#define USB_FUNCTION_BUSWAIT_12 (0x000au)
#define USB_FUNCTION_BUSWAIT_13 (0x000bu)
#define USB_FUNCTION_BUSWAIT_14 (0x000cu)
#define USB_FUNCTION_BUSWAIT_15 (0x000du)
#define USB_FUNCTION_BUSWAIT_16 (0x000eu)
#define USB_FUNCTION_BUSWAIT_17 (0x000fu)
#define USB_FUNCTION_BITRESUME (0x0020u)
#define USB_FUNCTION_BITUACT (0x0010u)
#define USB_FUNCTION_HSPROC (0x0004u)
#define USB_FUNCTION_HSMODE (0x0003u)
#define USB_FUNCTION_FSMODE (0x0002u)
#define USB_FUNCTION_LSMODE (0x0001u)
#define USB_FUNCTION_UNDECID (0x0000u)
#define USB_FUNCTION_BITRCNT (0x8000u)
#define USB_FUNCTION_BITDREQE (0x1000u)
#define USB_FUNCTION_BITMBW (0x0c00u)
#define USB_FUNCTION_BITMBW_8 (0x0000u)
#define USB_FUNCTION_BITMBW_16 (0x0400u)
#define USB_FUNCTION_BITMBW_32 (0x0800u)
#define USB_FUNCTION_BITBYTE_LITTLE (0x0000u)
#define USB_FUNCTION_BITBYTE_BIG (0x0100u)
#define USB_FUNCTION_BITISEL (0x0020u)
#define USB_FUNCTION_BITCURPIPE (0x000fu)
#define USB_FUNCTION_CFIFO_READ (0x0000u)
#define USB_FUNCTION_CFIFO_WRITE (0x0020u)
#define USB_FUNCTION_BITBVAL (0x8000u)
#define USB_FUNCTION_BITBCLR (0x4000u)
#define USB_FUNCTION_BITFRDY (0x2000u)
#define USB_FUNCTION_BITDTLN (0x0fffu)
#define USB_FUNCTION_BITVBSE (0x8000u)
#define USB_FUNCTION_BITRSME (0x4000u)
#define USB_FUNCTION_BITSOFE (0x2000u)
#define USB_FUNCTION_BITDVSE (0x1000u)
#define USB_FUNCTION_BITCTRE (0x0800u)
#define USB_FUNCTION_BITVBINT (0x8000u)
#define USB_FUNCTION_BITRESM (0x4000u)
#define USB_FUNCTION_BITSOFR (0x2000u)
#define USB_FUNCTION_BITDVST (0x1000u)
#define USB_FUNCTION_BITCTRT (0x0800u)
#define USB_FUNCTION_BITBEMPE (0x0400u)
#define USB_FUNCTION_BITNRDYE (0x0200u)
#define USB_FUNCTION_BITBRDYE (0x0100u)
#define USB_FUNCTION_BITBEMP (0x0400u)
#define USB_FUNCTION_BITNRDY (0x0200u)
#define USB_FUNCTION_BITBRDY (0x0100u)
#define USB_FUNCTION_BITDVSQ (0x0070u)
#define USB_FUNCTION_BITDVSQS (0x0030u)
#define USB_FUNCTION_DS_SPD_CNFG (0x0070u)
#define USB_FUNCTION_DS_SPD_ADDR (0x0060u)
#define USB_FUNCTION_DS_SPD_DFLT (0x0050u)
#define USB_FUNCTION_DS_SPD_POWR (0x0040u)
#define USB_FUNCTION_DS_CNFG (0x0030u)
#define USB_FUNCTION_DS_ADDS (0x0020u)
#define USB_FUNCTION_DS_DFLT (0x0010u)
#define USB_FUNCTION_DS_POWR (0x0000u)
#define USB_FUNCTION_BITVALID (0x0008u)
#define USB_FUNCTION_BITCTSQ (0x0007u)
#define USB_FUNCTION_CS_SQER (0x0006u)
#define USB_FUNCTION_CS_WRND (0x0005u)
#define USB_FUNCTION_CS_WRSS (0x0004u)
#define USB_FUNCTION_CS_WRDS (0x0003u)
#define USB_FUNCTION_CS_RDSS (0x0002u)
#define USB_FUNCTION_CS_RDDS (0x0001u)
#define USB_FUNCTION_CS_IDST (0x0000u)
#define USB_FUNCTION_PIPExBUF (64u)
#define USB_FUNCTION_D0FIFO (0)
#define USB_FUNCTION_D1FIFO (1)
#define USB_FUNCTION_DMA_READY (0)
#define USB_FUNCTION_DMA_BUSY (1)
#define USB_FUNCTION_DMA_BUSYEND (2)
#define USB_FUNCTION_FIFO_USE (0x7000)
#endif /* USB_FUNCTION_FUNCTION_H */
/* End of File */

32
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h Normal file
View file

@ -0,0 +1,32 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb_function_version.h
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Description : RZ/A1H R7S72100 USB Sample Program
*******************************************************************************/
#define USB_FUNCTION_LOCAL_Rev "VER080_140709"
/* End of File */

171
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function.h Normal file
View file

@ -0,0 +1,171 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function.h
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Description : RZ/A1H R7S72100 USB Sample Program
*******************************************************************************/
#ifndef USB0_FUNCTION_H
#define USB0_FUNCTION_H
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "devdrv_usb_function_api.h"
#include "usb_function.h"
#ifdef __cplusplus
extern "C" {
#endif
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
extern const uint16_t g_usb0_function_bit_set[];
extern uint32_t g_usb0_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1];
extern uint8_t *g_usb0_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1];
extern uint16_t g_usb0_function_PipeIgnore[];
extern uint16_t g_usb0_function_PipeTbl[];
extern uint16_t g_usb0_function_pipe_status[];
extern uint32_t g_usb0_function_PipeDataSize[];
extern USB_FUNCTION_DMA_t g_usb0_function_DmaInfo[];
extern uint16_t g_usb0_function_DmaPipe[];
extern uint16_t g_usb0_function_DmaBval[];
extern uint16_t g_usb0_function_DmaStatus[];
extern uint16_t g_usb0_function_CtrZeroLengthFlag;
extern uint16_t g_usb0_function_ConfigNum;
extern uint16_t g_usb0_function_Alternate[USB_FUNCTION_ALT_NO];
extern uint16_t g_usb0_function_RemoteWakeupFlag;
extern uint16_t g_usb0_function_TestModeFlag;
extern uint16_t g_usb0_function_TestModeSelectors;
extern uint16_t g_usb0_function_ReqType;
extern uint16_t g_usb0_function_ReqTypeType;
extern uint16_t g_usb0_function_ReqTypeRecip;
extern uint16_t g_usb0_function_ReqRequest;
extern uint16_t g_usb0_function_ReqValue;
extern uint16_t g_usb0_function_ReqIndex;
extern uint16_t g_usb0_function_ReqLength;
extern uint16_t g_usb0_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1];
extern uint16_t g_usb0_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1];
extern uint16_t g_usb0_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1];
extern uint16_t g_usb0_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1];
extern uint16_t g_usb0_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1];
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/* ==== common ==== */
void usb0_function_dma_stop_d0(uint16_t pipe, uint32_t remain);
void usb0_function_dma_stop_d1(uint16_t pipe, uint32_t remain);
uint16_t usb0_function_is_hispeed(void);
uint16_t usb0_function_is_hispeed_enable(void);
uint16_t usb0_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
uint16_t usb0_function_write_buffer(uint16_t pipe);
uint16_t usb0_function_write_buffer_c(uint16_t pipe);
uint16_t usb0_function_write_buffer_d0(uint16_t pipe);
uint16_t usb0_function_write_buffer_d1(uint16_t pipe);
void usb0_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
uint16_t usb0_function_read_buffer(uint16_t pipe);
uint16_t usb0_function_read_buffer_c(uint16_t pipe);
uint16_t usb0_function_read_buffer_d0(uint16_t pipe);
uint16_t usb0_function_read_buffer_d1(uint16_t pipe);
uint16_t usb0_function_change_fifo_port(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
void usb0_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
void usb0_function_set_curpipe2(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc);
uint16_t usb0_function_get_mbw(uint32_t trncount, uint32_t dtptr);
uint16_t usb0_function_read_dma(uint16_t pipe);
void usb0_function_brdy_int(uint16_t status, uint16_t int_enb);
void usb0_function_nrdy_int(uint16_t status, uint16_t int_enb);
void usb0_function_bemp_int(uint16_t status, uint16_t int_enb);
void usb0_function_setting_interrupt(uint8_t level);
void usb0_function_reset_module(uint16_t clockmode);
uint16_t usb0_function_get_buf_size(uint16_t pipe);
uint16_t usb0_function_get_mxps(uint16_t pipe);
void usb0_function_clear_brdy_sts(uint16_t pipe);
void usb0_function_clear_bemp_sts(uint16_t pipe);
void usb0_function_clear_nrdy_sts(uint16_t pipe);
void usb0_function_set_pid_buf(uint16_t pipe);
void usb0_function_set_pid_nak(uint16_t pipe);
void usb0_function_set_pid_stall(uint16_t pipe);
void usb0_function_clear_pid_stall(uint16_t pipe);
uint16_t usb0_function_get_pid(uint16_t pipe);
void usb0_function_set_sqclr(uint16_t pipe);
void usb0_function_set_sqset(uint16_t pipe);
void usb0_function_set_csclr(uint16_t pipe);
void usb0_function_aclrm(uint16_t pipe);
void usb0_function_set_aclrm(uint16_t pipe);
void usb0_function_clr_aclrm(uint16_t pipe);
uint16_t usb0_function_get_sqmon(uint16_t pipe);
uint16_t usb0_function_get_inbuf(uint16_t pipe);
/* ==== function ==== */
void usb0_function_init_status(void);
void usb0_function_InitModule(uint16_t mode);
uint16_t usb0_function_CheckVBUStaus(void);
void usb0_function_USB_FUNCTION_Attach(void);
void usb0_function_USB_FUNCTION_Detach(void);
void usb0_function_USB_FUNCTION_BusReset(void);
void usb0_function_USB_FUNCTION_Resume(void);
void usb0_function_USB_FUNCTION_Suspend(void);
void usb0_function_USB_FUNCTION_TestMode(void);
void usb0_function_ResetDCP(void);
void usb0_function_ResetEP(uint16_t num);
uint16_t usb0_function_EpToPipe(uint16_t ep);
void usb0_function_InitEPTable(uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num);
uint16_t usb0_function_GetConfigNum(void);
uint16_t usb0_function_GetAltNum(uint16_t Con_Num, uint16_t Int_Num);
uint16_t usb0_function_CheckRemoteWakeup(void);
void usb0_function_clear_alt(void);
void usb0_function_clear_pipe_tbl(void);
void usb0_function_clear_ep_table_index(void);
uint16_t usb0_function_GetInterfaceNum(uint16_t num);
#ifdef __cplusplus
}
#endif
#endif /* USB0_FUNCTION_H */
/* End of File */

104
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_api.h Normal file
View file

@ -0,0 +1,104 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_api.h
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Description : RZ/A1H R7S72100 USB Sample Program
*******************************************************************************/
#ifndef USB0_FUNCTION_API_H
#define USB0_FUNCTION_API_H
#ifdef __cplusplus
extern "C" {
#endif
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Variable Externs
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
void usb0_api_function_init(uint8_t int_level, uint16_t mode, uint16_t clockmode);
uint16_t usb0_api_function_IsConfigured(void);
uint16_t usb0_function_GetDeviceState(void);
uint16_t usb0_api_function_CtrlReadStart(uint32_t size, uint8_t *data);
void usb0_api_function_CtrlWriteStart(uint32_t size, uint8_t *data);
uint16_t usb0_api_function_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
uint16_t usb0_api_function_check_pipe_status(uint16_t pipe, uint32_t *size);
void usb0_api_function_clear_pipe_status(uint16_t pipe);
void usb0_api_function_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
void usb0_api_function_set_pid_buf(uint16_t pipe);
void usb0_api_function_set_pid_nak(uint16_t pipe);
void usb0_api_function_set_pid_stall(uint16_t pipe);
void usb0_api_function_clear_pid_stall(uint16_t pipe);
uint16_t usb0_api_function_get_pid(uint16_t pipe);
int32_t usb0_api_function_check_stall(uint16_t pipe);
void usb0_api_function_set_sqclr(uint16_t pipe);
void usb0_api_function_set_sqset(uint16_t pipe);
void usb0_api_function_set_csclr(uint16_t pipe);
void usb0_api_function_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
void usb0_api_function_clear_brdy_sts(uint16_t pipe);
void usb0_api_function_clear_bemp_sts(uint16_t pipe);
void usb0_api_function_clear_nrdy_sts(uint16_t pipe);
void usb0_function_ClearFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_SetFeature(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_SetAddress(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_SetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_SetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_SetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_SynchFrame(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_GetStatus(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_GetDescriptor(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_GetConfiguration(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_GetInterface(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_Resrv_0(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_Resrv_123(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_Resrv_4(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
void usb0_function_Resrv_5(uint16_t type, uint16_t value, uint16_t index, uint16_t length);
#ifdef __cplusplus
}
#endif
#endif /* USB0_FUNCTION_API_H */
/* End of File */

142
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_dmacdrv.h Normal file
View file

@ -0,0 +1,142 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_dmacdrv.h
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Description : RZ/A1H R7S72100 USB Sample Program
*******************************************************************************/
#ifndef USB0_FUNCTION_DMACDRV_H
#define USB0_FUNCTION_DMACDRV_H
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
/*******************************************************************************
Typedef definitions
*******************************************************************************/
typedef struct dmac_transinfo
{
uint32_t src_addr; /* Transfer source address */
uint32_t dst_addr; /* Transfer destination address */
uint32_t count; /* Transfer byte count */
uint32_t src_size; /* Transfer source data size */
uint32_t dst_size; /* Transfer destination data size */
uint32_t saddr_dir; /* Transfer source address direction */
uint32_t daddr_dir; /* Transfer destination address direction */
} dmac_transinfo_t;
/*******************************************************************************
Macro definitions
*******************************************************************************/
/* ==== Transfer specification of the sample program ==== */
#define DMAC_SAMPLE_SINGLE (0) /* Single transfer */
#define DMAC_SAMPLE_CONTINUATION (1) /* Continuous transfer (use REN bit) */
/* ==== DMA modes ==== */
#define DMAC_MODE_REGISTER (0) /* Register mode */
#define DMAC_MODE_LINK (1) /* Link mode */
/* ==== Transfer requests ==== */
#define DMAC_REQ_MODE_EXT (0) /* External request */
#define DMAC_REQ_MODE_PERI (1) /* On-chip peripheral module request */
#define DMAC_REQ_MODE_SOFT (2) /* Auto-request (request by software) */
/* ==== DMAC transfer sizes ==== */
#define DMAC_TRANS_SIZE_8 (0) /* 8 bits */
#define DMAC_TRANS_SIZE_16 (1) /* 16 bits */
#define DMAC_TRANS_SIZE_32 (2) /* 32 bits */
#define DMAC_TRANS_SIZE_64 (3) /* 64 bits */
#define DMAC_TRANS_SIZE_128 (4) /* 128 bits */
#define DMAC_TRANS_SIZE_256 (5) /* 256 bits */
#define DMAC_TRANS_SIZE_512 (6) /* 512 bits */
#define DMAC_TRANS_SIZE_1024 (7) /* 1024 bits */
/* ==== Address increment for transferring ==== */
#define DMAC_TRANS_ADR_NO_INC (1) /* Not increment */
#define DMAC_TRANS_ADR_INC (0) /* Increment */
/* ==== Method for detecting DMA request ==== */
#define DMAC_REQ_DET_FALL (0) /* Falling edge detection */
#define DMAC_REQ_DET_RISE (1) /* Rising edge detection */
#define DMAC_REQ_DET_LOW (2) /* Low level detection */
#define DMAC_REQ_DET_HIGH (3) /* High level detection */
/* ==== Request Direction ==== */
#define DMAC_REQ_DIR_SRC (0) /* DMAREQ is the source/ DMAACK is active when reading */
#define DMAC_REQ_DIR_DST (1) /* DMAREQ is the destination/ DMAACK is active when writing */
/* ==== Descriptors ==== */
#define DMAC_DESC_HEADER (0) /* Header */
#define DMAC_DESC_SRC_ADDR (1) /* Source Address */
#define DMAC_DESC_DST_ADDR (2) /* Destination Address */
#define DMAC_DESC_COUNT (3) /* Transaction Byte */
#define DMAC_DESC_CHCFG (4) /* Channel Confg */
#define DMAC_DESC_CHITVL (5) /* Channel Interval */
#define DMAC_DESC_CHEXT (6) /* Channel Extension */
#define DMAC_DESC_LINK_ADDR (7) /* Link Address */
/* ==== On-chip peripheral module requests ===== */
typedef enum dmac_request_factor
{
DMAC_REQ_USB0_DMA0_TX, /* USB_0 channel 0 transmit FIFO empty */
DMAC_REQ_USB0_DMA0_RX, /* USB_0 channel 0 receive FIFO full */
DMAC_REQ_USB0_DMA1_TX, /* USB_0 channel 1 transmit FIFO empty */
DMAC_REQ_USB0_DMA1_RX, /* USB_0 channel 1 receive FIFO full */
DMAC_REQ_USB1_DMA0_TX, /* USB_1 channel 0 transmit FIFO empty */
DMAC_REQ_USB1_DMA0_RX, /* USB_1 channel 0 receive FIFO full */
DMAC_REQ_USB1_DMA1_TX, /* USB_1 channel 1 transmit FIFO empty */
DMAC_REQ_USB1_DMA1_RX, /* USB_1 channel 1 receive FIFO full */
} dmac_request_factor_t;
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
void usb0_function_DMAC1_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation,
uint32_t request_factor, uint32_t req_direction);
int32_t usb0_function_DMAC1_Open(uint32_t req);
void usb0_function_DMAC1_Close(uint32_t *remain);
void usb0_function_DMAC1_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count);
void usb0_function_DMAC2_PeriReqInit(const dmac_transinfo_t *trans_info, uint32_t dmamode, uint32_t continuation,
uint32_t request_factor, uint32_t req_direction);
int32_t usb0_function_DMAC2_Open(uint32_t req);
void usb0_function_DMAC2_Close(uint32_t *remain);
void usb0_function_DMAC2_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count);
#ifdef __cplusplus
}
#endif
#endif /* USB0_FUNCTION_DMACDRV_H */
/* End of File */

2933
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.c Normal file
View file

File diff suppressed because it is too large Load diff

346
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dma.c Normal file
View file

@ -0,0 +1,346 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_dma.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "usb0_function.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
static void usb0_function_dmaint(uint16_t fifo);
static void usb0_function_dmaint_buf2fifo(uint16_t pipe);
static void usb0_function_dmaint_fifo2buf(uint16_t pipe);
/*******************************************************************************
* Function Name: usb0_function_dma_stop_d0
* Description : D0FIFO DMA stop
* Arguments : uint16_t pipe : pipe number
* : uint32_t remain : transfer byte
* Return Value : none
*******************************************************************************/
void usb0_function_dma_stop_d0 (uint16_t pipe, uint32_t remain)
{
uint16_t dtln;
uint16_t dfacc;
uint16_t buffer;
uint16_t sds_b = 1;
dfacc = RZA_IO_RegRead_16(&USB200.D0FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC);
if (dfacc == 2)
{
sds_b = 32;
}
else if (dfacc == 1)
{
sds_b = 16;
}
else
{
if (g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 2)
{
sds_b = 4;
}
else if (g_usb0_function_DmaInfo[USB_FUNCTION_D0FIFO].size == 1)
{
sds_b = 2;
}
else
{
sds_b = 1;
}
}
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
{
if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE)
{
buffer = USB200.D0FIFOCTR;
dtln = (buffer & USB_FUNCTION_BITDTLN);
if ((dtln % sds_b) != 0)
{
remain += (sds_b - (dtln % sds_b));
}
g_usb0_function_PipeDataSize[pipe] = (g_usb0_function_data_count[pipe] - remain);
g_usb0_function_data_count[pipe] = remain;
}
}
RZA_IO_RegWrite_16(&USB200.D0FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
}
/*******************************************************************************
* Function Name: usb0_function_dma_stop_d1
* Description : D1FIFO DMA stop
* Arguments : uint16_t pipe : pipe number
* : uint32_t remain : transfer byte
* Return Value : none
*******************************************************************************/
void usb0_function_dma_stop_d1 (uint16_t pipe, uint32_t remain)
{
uint16_t dtln;
uint16_t dfacc;
uint16_t buffer;
uint16_t sds_b = 1;
dfacc = RZA_IO_RegRead_16(&USB200.D1FBCFG, USB_DnFBCFG_DFACC_SHIFT, USB_DnFBCFG_DFACC);
if (dfacc == 2)
{
sds_b = 32;
}
else if (dfacc == 1)
{
sds_b = 16;
}
else
{
if (g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 2)
{
sds_b = 4;
}
else if (g_usb0_function_DmaInfo[USB_FUNCTION_D1FIFO].size == 1)
{
sds_b = 2;
}
else
{
sds_b = 1;
}
}
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
{
if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE)
{
buffer = USB200.D1FIFOCTR;
dtln = (buffer & USB_FUNCTION_BITDTLN);
if ((dtln % sds_b) != 0)
{
remain += (sds_b - (dtln % sds_b));
}
g_usb0_function_PipeDataSize[pipe] = (g_usb0_function_data_count[pipe] - remain);
g_usb0_function_data_count[pipe] = remain;
}
}
RZA_IO_RegWrite_16(&USB200.D1FIFOSEL, 0, USB_DnFIFOSEL_DREQE_SHIFT, USB_DnFIFOSEL_DREQE);
}
/*******************************************************************************
* Function Name: usb0_function_dma_interrupt_d0fifo
* Description : This function is DMA interrupt handler entry.
* : Execute usb0_function_dmaint() after disabling DMA interrupt in this function.
* : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D0FIFO_DMA is
* : specified by dma->fifo.
* : Register this function as DMA complete interrupt.
* Arguments : uint32_t int_sense ; Interrupts detection mode
* : ; INTC_LEVEL_SENSITIVE : Level sense
* : ; INTC_EDGE_TRIGGER : Edge trigger
* Return Value : none
*******************************************************************************/
void usb0_function_dma_interrupt_d0fifo (uint32_t int_sense)
{
usb0_function_dmaint(USB_FUNCTION_D0FIFO);
g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] = USB_FUNCTION_DMA_READY;
}
/*******************************************************************************
* Function Name: usb0_function_dma_interrupt_d1fifo
* Description : This function is DMA interrupt handler entry.
* : Execute usb0_function_dmaint() after disabling DMA interrupt in this function.
* : Disable DMA interrupt to DMAC executed when USB_FUNCTION_D1FIFO_DMA is
* : specified by dma->fifo.
* : Register this function as DMA complete interrupt.
* Arguments : uint32_t int_sense ; Interrupts detection mode
* : ; INTC_LEVEL_SENSITIVE : Level sense
* : ; INTC_EDGE_TRIGGER : Edge trigger
* Return Value : none
*******************************************************************************/
void usb0_function_dma_interrupt_d1fifo (uint32_t int_sense)
{
usb0_function_dmaint(USB_FUNCTION_D1FIFO);
g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] = USB_FUNCTION_DMA_READY;
}
/*******************************************************************************
* Function Name: usb0_function_dmaint
* Description : This function is DMA transfer end interrupt
* Arguments : uint16_t fifo ; fifo number
* : ; USB_FUNCTION_D0FIFO
* : ; USB_FUNCTION_D1FIFO
* Return Value : none
*******************************************************************************/
static void usb0_function_dmaint (uint16_t fifo)
{
uint16_t pipe;
pipe = g_usb0_function_DmaPipe[fifo];
if (g_usb0_function_DmaInfo[fifo].dir == USB_FUNCTION_BUF2FIFO)
{
usb0_function_dmaint_buf2fifo(pipe);
}
else
{
usb0_function_dmaint_fifo2buf(pipe);
}
}
/*******************************************************************************
* Function Name: usb0_function_dmaint_fifo2buf
* Description : Executes read completion from FIFO by DMAC.
* Arguments : uint16_t pipe : pipe number
* Return Value : none
*******************************************************************************/
static void usb0_function_dmaint_fifo2buf (uint16_t pipe)
{
uint32_t remain;
uint16_t useport;
if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_DONE)
{
useport = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
if (useport == USB_FUNCTION_D0FIFO_DMA)
{
remain = Userdef_USB_usb0_function_stop_dma0();
usb0_function_dma_stop_d0(pipe, remain);
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
{
if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] == USB_FUNCTION_DMA_BUSYEND)
{
USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
}
else
{
usb0_function_enable_brdy_int(pipe);
}
}
}
else
{
remain = Userdef_USB_usb0_function_stop_dma1();
usb0_function_dma_stop_d1(pipe, remain);
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
{
if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] == USB_FUNCTION_DMA_BUSYEND)
{
USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
}
else
{
usb0_function_enable_brdy_int(pipe);
}
}
}
}
}
/*******************************************************************************
* Function Name: usb0_function_dmaint_buf2fifo
* Description : Executes write completion in FIFO by DMAC.
* Arguments : uint16_t pipe : pipe number
* Return Value : none
*******************************************************************************/
static void usb0_function_dmaint_buf2fifo (uint16_t pipe)
{
uint32_t remain;
uint16_t useport;
useport = (uint16_t)(g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE);
if (useport == USB_FUNCTION_D0FIFO_DMA)
{
remain = Userdef_USB_usb0_function_stop_dma0();
usb0_function_dma_stop_d0(pipe, remain);
if (g_usb0_function_DmaBval[USB_FUNCTION_D0FIFO] != 0)
{
RZA_IO_RegWrite_16(&USB200.D0FIFOCTR,
1,
USB_DnFIFOCTR_BVAL_SHIFT,
USB_DnFIFOCTR_BVAL);
}
}
else
{
remain = Userdef_USB_usb0_function_stop_dma1();
usb0_function_dma_stop_d1(pipe, remain);
if (g_usb0_function_DmaBval[USB_FUNCTION_D1FIFO] != 0)
{
RZA_IO_RegWrite_16(&USB200.D1FIFOCTR,
1,
USB_DnFIFOCTR_BVAL_SHIFT,
USB_DnFIFOCTR_BVAL);
}
}
usb0_function_enable_bemp_int(pipe);
}
/* End of File */

249
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_intrn.c Normal file
View file

@ -0,0 +1,249 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_intrn.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "usb0_function.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
/*******************************************************************************
* Function Name: usb0_function_brdy_int
* Description : Executes BRDY interrupt(USB_FUNCTION_PIPE1-9).
* : According to the pipe that interrupt is generated in,
* : reads/writes buffer allocated in the pipe.
* : This function is executed in the BRDY interrupt handler.
* : This function clears BRDY interrupt status and BEMP interrupt
* : status.
* Arguments : uint16_t Status ; BRDYSTS Register Value
* : uint16_t Int_enbl ; BRDYENB Register Value
* Return Value : none
*******************************************************************************/
#if 0
void usb0_function_brdy_int (uint16_t status, uint16_t int_enb)
{
uint32_t int_sense = 0;
uint16_t pipe;
uint16_t pipebit;
for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
{
pipebit = g_usb0_function_bit_set[pipe];
if ((status & pipebit) && (int_enb & pipebit))
{
USB200.BRDYSTS = (uint16_t)~pipebit;
USB200.BEMPSTS = (uint16_t)~pipebit;
if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA)
{
if (g_usb0_function_DmaStatus[USB_FUNCTION_D0FIFO] != USB_FUNCTION_DMA_READY)
{
usb0_function_dma_interrupt_d0fifo(int_sense);
}
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
{
usb0_function_read_dma(pipe);
usb0_function_disable_brdy_int(pipe);
}
else
{
USB200.D0FIFOCTR = USB_FUNCTION_BITBCLR;
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
}
}
else if ((g_usb0_function_PipeTbl[pipe] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA)
{
if (g_usb0_function_DmaStatus[USB_FUNCTION_D1FIFO] != USB_FUNCTION_DMA_READY)
{
usb0_function_dma_interrupt_d1fifo(int_sense);
}
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
{
usb0_function_read_dma(pipe);
usb0_function_disable_brdy_int(pipe);
}
else
{
USB200.D1FIFOCTR = USB_FUNCTION_BITBCLR;
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
}
}
else
{
if (RZA_IO_RegRead_16(&g_usb0_function_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0)
{
usb0_function_read_buffer(pipe);
}
else
{
usb0_function_write_buffer(pipe);
}
}
}
}
}
#endif
/*******************************************************************************
* Function Name: usb0_function_nrdy_int
* Description : Executes NRDY interrupt(USB_FUNCTION_PIPE1-9).
* : Checks NRDY interrupt cause by PID. When the cause if STALL,
* : regards the pipe state as STALL and ends the processing.
* : Then the cause is not STALL, increments the error count to
* : communicate again. When the error count is 3, determines
* : the pipe state as DEVDRV_USBF_PIPE_NORES and ends the processing.
* : This function is executed in the NRDY interrupt handler.
* : This function clears NRDY interrupt status.
* Arguments : uint16_t status ; NRDYSTS Register Value
* : uint16_t int_enb ; NRDYENB Register Value
* Return Value : none
*******************************************************************************/
void usb0_function_nrdy_int (uint16_t status, uint16_t int_enb)
{
uint16_t pid;
uint16_t pipe;
uint16_t bitcheck;
bitcheck = (uint16_t)(status & int_enb);
USB200.NRDYSTS = (uint16_t)~status;
for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
{
if ((bitcheck&g_usb0_function_bit_set[pipe]) == g_usb0_function_bit_set[pipe])
{
if (RZA_IO_RegRead_16(&USB200.SYSCFG0, USB_SYSCFG_DCFM_SHIFT, USB_SYSCFG_DCFM) == 1)
{
if (g_usb0_function_pipe_status[pipe] == DEVDRV_USBF_PIPE_WAIT)
{
pid = usb0_function_get_pid(pipe);
if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2))
{
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL;
}
else
{
g_usb0_function_PipeIgnore[pipe]++;
if (g_usb0_function_PipeIgnore[pipe] == 3)
{
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_NORES;
}
else
{
usb0_function_set_pid_buf(pipe);
}
}
}
}
else
{
/* USB Function */
}
}
}
}
/*******************************************************************************
* Function Name: usb0_function_bemp_int
* Description : Executes BEMP interrupt(USB_FUNCTION_PIPE1-9).
* Arguments : uint16_t status ; BEMPSTS Register Value
* : uint16_t int_enb ; BEMPENB Register Value
* Return Value : none
*******************************************************************************/
void usb0_function_bemp_int (uint16_t status, uint16_t int_enb)
{
uint16_t pid;
uint16_t pipe;
uint16_t bitcheck;
uint16_t inbuf;
bitcheck = (uint16_t)(status & int_enb);
USB200.BEMPSTS = (uint16_t)~status;
for (pipe = USB_FUNCTION_PIPE1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
{
if ((bitcheck&g_usb0_function_bit_set[pipe]) == g_usb0_function_bit_set[pipe])
{
pid = usb0_function_get_pid(pipe);
if ((pid == DEVDRV_USBF_PID_STALL) || (pid == DEVDRV_USBF_PID_STALL2))
{
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_STALL;
}
else
{
inbuf = usb0_function_get_inbuf(pipe);
if (inbuf == 0)
{
usb0_function_disable_bemp_int(pipe);
usb0_function_set_pid_nak(pipe);
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_DONE;
}
}
}
}
}
/* End of File */

2026
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_lib.c Normal file
View file

File diff suppressed because it is too large Load diff

441
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_api.c Normal file
View file

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

142
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_controlrw.c Normal file
View file

@ -0,0 +1,142 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_controlrw.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "usb0_function.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
/*******************************************************************************
* Function Name: usb0_api_function_CtrlReadStart
* Description : Executes the USB control read transfer.
* : USB host controller <- USB device
* Arguments : uint16_t size ; Data Size
* : uint8_t *data ; Data Address
* Return Value : DEVDRV_USBF_WRITEEND ; End of data write
* : DEVDRV_USBF_WRITESHRT ; End of short data write
* : DEVDRV_USBF_WRITING ; Continue of data write
* : DEVDRV_USBF_FIFOERROR ; FIFO access error
*******************************************************************************/
uint16_t usb0_api_function_CtrlReadStart (uint32_t size, uint8_t * data)
{
uint16_t status;
uint16_t mbw;
usb0_function_set_pid_nak(USB_FUNCTION_PIPE0);
g_usb0_function_data_count[USB_FUNCTION_PIPE0] = size;
g_usb0_function_data_pointer[USB_FUNCTION_PIPE0] = data;
mbw = usb0_function_get_mbw(g_usb0_function_data_count[USB_FUNCTION_PIPE0],
(uint32_t)g_usb0_function_data_pointer[USB_FUNCTION_PIPE0]);
usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw);
USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;
status = usb0_function_write_buffer_c(USB_FUNCTION_PIPE0);
/* Peripheral Control sequence */
switch (status)
{
case DEVDRV_USBF_WRITESHRT: /* End of data write */
case DEVDRV_USBF_WRITEEND: /* End of data write (not null) */
case DEVDRV_USBF_WRITING: /* Continue of data write */
usb0_function_enable_bemp_int(USB_FUNCTION_PIPE0); /* Enable Empty Interrupt */
usb0_function_set_pid_buf(USB_FUNCTION_PIPE0); /* Set BUF */
break;
case DEVDRV_USBF_FIFOERROR: /* FIFO access error */
break;
default:
break;
}
return status; /* End or Err or Continue */
}
/*******************************************************************************
* Function Name: usb0_api_function_CtrlWriteStart
* Description : Executes the USB control write transfer.
* : USB host controller -> USB device
* Arguments : uint16_t size ; Data Size
* : uint8_t *data ; Data Address
* Return Value : none
*******************************************************************************/
void usb0_api_function_CtrlWriteStart (uint32_t size, uint8_t * data)
{
uint16_t mbw;
usb0_function_set_pid_nak(USB_FUNCTION_PIPE0);
g_usb0_function_data_count[USB_FUNCTION_PIPE0] = size;
g_usb0_function_data_pointer[USB_FUNCTION_PIPE0] = data;
mbw = usb0_function_get_mbw(g_usb0_function_data_count[USB_FUNCTION_PIPE0],
(uint32_t)g_usb0_function_data_pointer[USB_FUNCTION_PIPE0]);
usb0_function_set_curpipe(USB_FUNCTION_PIPE0, USB_FUNCTION_CUSE, USB_FUNCTION_CFIFO_WRITE, mbw);
USB200.CFIFOCTR = USB_FUNCTION_BITBCLR;
usb0_function_enable_brdy_int(USB_FUNCTION_PIPE0);
usb0_function_set_pid_buf(USB_FUNCTION_PIPE0);
}
/* End of File */

144
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_global.c Normal file
View file

@ -0,0 +1,144 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_global.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "usb0_function.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
const uint16_t g_usb0_function_bit_set[16] =
{
0x0001, 0x0002, 0x0004, 0x0008,
0x0010, 0x0020, 0x0040, 0x0080,
0x0100, 0x0200, 0x0400, 0x0800,
0x1000, 0x2000, 0x4000, 0x8000
};
uint32_t g_usb0_function_data_count[USB_FUNCTION_MAX_PIPE_NO + 1];
uint8_t * g_usb0_function_data_pointer[USB_FUNCTION_MAX_PIPE_NO + 1];
uint16_t g_usb0_function_PipeIgnore[USB_FUNCTION_MAX_PIPE_NO + 1];
uint16_t g_usb0_function_PipeTbl[USB_FUNCTION_MAX_PIPE_NO + 1];
uint16_t g_usb0_function_pipe_status[USB_FUNCTION_MAX_PIPE_NO + 1];
uint32_t g_usb0_function_PipeDataSize[USB_FUNCTION_MAX_PIPE_NO + 1];
USB_FUNCTION_DMA_t g_usb0_function_DmaInfo[2];
uint16_t g_usb0_function_DmaPipe[2];
uint16_t g_usb0_function_DmaBval[2];
uint16_t g_usb0_function_DmaStatus[2];
uint16_t g_usb0_function_CtrZeroLengthFlag;
//uint16_t g_usb0_function_ConfigNum;
//uint16_t g_usb0_function_Alternate[USB_FUNCTION_ALT_NO];
//uint16_t g_usb0_function_RemoteWakeupFlag;
uint16_t g_usb0_function_TestModeFlag;
uint16_t g_usb0_function_TestModeSelectors;
//uint16_t g_usb0_function_ReqType;
//uint16_t g_usb0_function_ReqTypeType;
//uint16_t g_usb0_function_ReqTypeRecip;
//uint16_t g_usb0_function_ReqRequest;
//uint16_t g_usb0_function_ReqValue;
//uint16_t g_usb0_function_ReqIndex;
//uint16_t g_usb0_function_ReqLength;
//uint16_t g_usb0_function_EPTableIndex[USB_FUNCTION_MAX_EP_NO + 1];
uint16_t g_usb0_function_pipecfg[USB_FUNCTION_MAX_PIPE_NO + 1];
uint16_t g_usb0_function_pipebuf[USB_FUNCTION_MAX_PIPE_NO + 1];
uint16_t g_usb0_function_pipemaxp[USB_FUNCTION_MAX_PIPE_NO + 1];
uint16_t g_usb0_function_pipeperi[USB_FUNCTION_MAX_PIPE_NO + 1];
/*******************************************************************************
* Function Name: usb0_function_init_status
* Description : Initialization USB Sample Driver Variable.
* Arguments : none
* Return Value : none
*******************************************************************************/
void usb0_function_init_status (void)
{
uint16_t pipe;
//g_usb0_function_ConfigNum = 0;
//g_usb0_function_RemoteWakeupFlag = DEVDRV_USBF_OFF;
g_usb0_function_TestModeFlag = DEVDRV_USBF_OFF;
g_usb0_function_CtrZeroLengthFlag = 0;
#if 0
usb0_function_clear_alt();
#endif
for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe)
{
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
g_usb0_function_PipeDataSize[pipe] = 0;
g_usb0_function_data_count[pipe] = 0;
/* pipe configuration in usb0_function_ResetEP() */
g_usb0_function_pipecfg[pipe] = 0;
g_usb0_function_pipebuf[pipe] = 0;
g_usb0_function_pipemaxp[pipe] = 0;
g_usb0_function_pipeperi[pipe] = 0;
}
}
/* End of File */

330
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sig.c Normal file
View file

@ -0,0 +1,330 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_sig.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "usb0_function.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
static void usb0_function_EnableINTModule(void);
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
/*******************************************************************************
* Function Name: usb0_function_InitModule
* Description : Initializes the USB module in the USB function mode.
* Arguments : uint16_t mode ; USB_FUNCTION_HIGH_SPEED ; Hi-Speed Mode
* : ; other ; Full-speed Mode
* Return Value : none
*******************************************************************************/
void usb0_function_InitModule (uint16_t mode)
{
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
0,
USB_SYSCFG_DCFM_SHIFT,
USB_SYSCFG_DCFM); /* USB function */
/* USB module operation enabled */
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
1,
USB_SYSCFG_USBE_SHIFT,
USB_SYSCFG_USBE);
if (mode == USB_FUNCTION_HIGH_SPEED)
{
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
1,
USB_SYSCFG_HSE_SHIFT,
USB_SYSCFG_HSE); /* Hi-Speed Mode */
}
else
{
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
0,
USB_SYSCFG_HSE_SHIFT,
USB_SYSCFG_HSE);
}
/* for power-on */
if (usb0_function_CheckVBUStaus() == DEVDRV_USBF_ON)
{
usb0_function_EnableINTModule(); /* Interrupt Enable */
usb0_function_USB_FUNCTION_Attach(); /* pull-up D+ and open D- */
}
else
{
usb0_function_USB_FUNCTION_Detach(); /* USB Detach */
/* with Interrupt Enable */
}
}
/*******************************************************************************
* Function Name: usb0_function_CheckVBUStaus
* Description : Checks the USB-VBUS state to returns the connection state to
* : the USB host.
* Arguments : none
* Return Value : DEVDRV_USBF_ON : VBUS ON
* : DEVDRV_USBF_OFF : VBUS OFF
*******************************************************************************/
uint16_t usb0_function_CheckVBUStaus (void)
{
uint16_t buf1;
uint16_t buf2;
uint16_t buf3;
/* monitor VBUS pins */
do
{
buf1 = RZA_IO_RegRead_16(&USB200.INTSTS0,
USB_INTSTS0_VBSTS_SHIFT,
USB_INTSTS0_VBSTS);
Userdef_USB_usb0_function_delay_10us(1);
buf2 = RZA_IO_RegRead_16(&USB200.INTSTS0,
USB_INTSTS0_VBSTS_SHIFT,
USB_INTSTS0_VBSTS);
Userdef_USB_usb0_function_delay_10us(1);
buf3 = RZA_IO_RegRead_16(&USB200.INTSTS0,
USB_INTSTS0_VBSTS_SHIFT,
USB_INTSTS0_VBSTS);
} while ((buf1 != buf2) || (buf2 != buf3));
if (buf1 == DEVDRV_USBF_OFF)
{
return DEVDRV_USBF_OFF; /* detach */
}
return DEVDRV_USBF_ON; /* attach */
}
/*******************************************************************************
* Function Name: usb0_function_USB_FUNCTION_Attach
* Description : Connects to the USB host controller.
* : This function pulls up D+.
* Arguments : none
* Return Value : none
*******************************************************************************/
void usb0_function_USB_FUNCTION_Attach (void)
{
Userdef_USB_usb0_function_attach();
Userdef_USB_usb0_function_delay_xms(10);
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
1,
USB_SYSCFG_DPRPU_SHIFT,
USB_SYSCFG_DPRPU); /* Pull-up D+ and open D- */
}
/*******************************************************************************
* Function Name: usb0_function_USB_FUNCTION_Detach
* Description : Disconnects from the USB host controller.
* : This function opens D+/D-.
* Arguments : none
* Return Value : none
*******************************************************************************/
void usb0_function_USB_FUNCTION_Detach (void)
{
uint16_t pipe;
Userdef_USB_usb0_function_detach();
for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe)
{
if (g_usb0_function_pipe_status[pipe] != DEVDRV_USBF_PIPE_IDLE)
{
usb0_function_stop_transfer(pipe);
}
}
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
0,
USB_SYSCFG_DPRPU_SHIFT,
USB_SYSCFG_DPRPU); /* open D+ and D- */
/* Detach Recovery */
Userdef_USB_usb0_function_delay_500ns(); /* need 1us=500ns * 2 wait */
Userdef_USB_usb0_function_delay_500ns();
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
1,
USB_SYSCFG_DCFM_SHIFT,
USB_SYSCFG_DCFM);
Userdef_USB_usb0_function_delay_500ns(); /* need 100ns wait but 500ns S/W wait */
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
0,
USB_SYSCFG_DCFM_SHIFT,
USB_SYSCFG_DCFM);
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
0,
USB_SYSCFG_USBE_SHIFT,
USB_SYSCFG_USBE); /* soft reset module */
Userdef_USB_usb0_function_delay_500ns();
RZA_IO_RegWrite_16(&USB200.SYSCFG0,
1,
USB_SYSCFG_USBE_SHIFT,
USB_SYSCFG_USBE);
usb0_function_EnableINTModule(); /* Interrupt Enable */
}
/*******************************************************************************
* Function Name: usb0_function_USB_FUNCTION_BusReset
* Description : This function is executed when the USB device is transitioned
* : to POWERD_STATE. Sets the device descriptor according to the
* : connection speed determined by the USB reset hand shake.
* Arguments : none
* Return Value : none
*******************************************************************************/
#if 0 /*The USBHAL in mbed does not need this function*/
void usb0_function_USB_FUNCTION_BusReset (void)
{
usb0_function_init_status(); /* memory clear */
if (usb0_function_is_hispeed() == USB_FUNCTION_HIGH_SPEED)
{
usb0_function_ResetDescriptor(USB_FUNCTION_HIGH_SPEED); /* Device Descriptor reset */
}
else
{
usb0_function_ResetDescriptor(USB_FUNCTION_FULL_SPEED); /* Device Descriptor reset */
}
usb0_function_ResetDCP(); /* Default Control PIPE reset */
}
#endif
/*******************************************************************************
* Function Name: usb0_function_USB_FUNCTION_Resume
* Description : This function is executed when the USB device detects a resume
* : signal.
* : The USB sample driver does not operate for this function.
* Arguments : none
* Return Value : none
*******************************************************************************/
#if 0 /*The USBHAL in mbed does not need this function*/
void usb0_function_USB_FUNCTION_Resume (void)
{
/* NOP */
}
#endif
/*******************************************************************************
* Function Name: usb0_function_USB_FUNCTION_Suspend
* Description : This function is executed when the USB device detects a suspend
* : signal.
* : The USB sample driver does not operate for this function.
* Arguments : none
* Return Value : none
*******************************************************************************/
#if 0 /*The USBHAL in mbed does not need this function*/
void usb0_function_USB_FUNCTION_Suspend (void)
{
/* NOP */
}
#endif
/*******************************************************************************
* Function Name: usb0_function_USB_FUNCTION_TestMode
* Description : This function is executed when the USB device is transitioned U
* : to TEST_MODE by the USB standard request.
* Arguments : none
* Return Value : none
*******************************************************************************/
void usb0_function_USB_FUNCTION_TestMode (void)
{
switch (g_usb0_function_TestModeSelectors & USB_FUNCTION_FUNCTION_TEST_SELECT)
{
case USB_FUNCTION_FUNCTION_TEST_J:
case USB_FUNCTION_FUNCTION_TEST_K:
case USB_FUNCTION_FUNCTION_TEST_SE0_NAK:
case USB_FUNCTION_FUNCTION_TEST_PACKET:
RZA_IO_RegWrite_16(&USB200.TESTMODE,
(g_usb0_function_TestModeSelectors >> 8),
USB_TESTMODE_UTST_SHIFT,
USB_TESTMODE_UTST);
break;
case USB_FUNCTION_FUNCTION_TEST_FORCE_ENABLE:
default:
break;
}
}
/*******************************************************************************
* Function Name: usb0_function_EnableINTModule
* Description : Enables USB interrupt.
* Arguments : none
* Return Value : none
*******************************************************************************/
static void usb0_function_EnableINTModule (void)
{
uint16_t buf;
buf = USB200.INTENB0;
buf |= (USB_FUNCTION_BITVBSE | USB_FUNCTION_BITDVSE | USB_FUNCTION_BITCTRE |
USB_FUNCTION_BITBEMPE | USB_FUNCTION_BITNRDYE | USB_FUNCTION_BITBRDYE);
USB200.INTENB0 = buf;
usb0_function_enable_bemp_int(USB_FUNCTION_PIPE0);
}
/* End of File */

453
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sub.c Normal file
View file

@ -0,0 +1,453 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_sub.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include "usb0_function.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
#if 0
extern const uint16_t *g_usb0_function_EndPntPtr[];
extern uint8_t g_usb0_function_DeviceDescriptor[];
extern uint8_t *g_usb0_function_ConfigurationPtr[];
#endif
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
/*******************************************************************************
* Function Name: usb0_function_ResetDCP
* Description : Initializes the default control pipe(DCP).
* Outline : Reset default control pipe
* Arguments : none
* Return Value : none
*******************************************************************************/
void usb0_function_ResetDCP (void)
{
USB200.DCPCFG = 0;
#if 0
USB200.DCPMAXP = g_usb0_function_DeviceDescriptor[7];
#else
USB200.DCPMAXP = 64;
#endif
USB200.CFIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
USB200.D0FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
USB200.D1FIFOSEL = (uint16_t)(USB_FUNCTION_BITMBW_8 | USB_FUNCTION_BITBYTE_LITTLE);
}
/*******************************************************************************
* Function Name: usb0_function_ResetEP
* Description : Initializes the end point.
* Arguments : uint16_t num ; Configuration Number
* Return Value : none
*******************************************************************************/
#if 0
void usb0_function_ResetEP (uint16_t num)
{
uint16_t pipe;
uint16_t ep;
uint16_t index;
uint16_t buf;
uint16_t * tbl;
tbl = (uint16_t *)(g_usb0_function_EndPntPtr[num - 1]);
for (ep = 1; ep <= USB_FUNCTION_MAX_EP_NO; ++ep)
{
if (g_usb0_function_EPTableIndex[ep] != USB_FUNCTION_EP_ERROR)
{
index = (uint16_t)(USB_FUNCTION_EPTABLE_LENGTH * g_usb0_function_EPTableIndex[ep]);
pipe = (uint16_t)(tbl[index + 0] & USB_FUNCTION_BITCURPIPE);
g_usb0_function_PipeTbl[pipe] = (uint16_t)( ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) << 3) |
ep |
(tbl[index + 0] & USB_FUNCTION_FIFO_USE) );
if ((tbl[index + 1] & USB_FUNCTION_DIRFIELD) == USB_FUNCTION_DIR_P_OUT)
{
tbl[index + 1] |= USB_FUNCTION_SHTNAKON;
#ifdef __USB_DMA_BFRE_ENABLE__
/* this routine cannnot be perfomred if read operation is executed in buffer size */
if (((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D0FIFO_DMA) ||
((tbl[index + 0] & USB_FUNCTION_FIFO_USE) == USB_FUNCTION_D1FIFO_DMA))
{
tbl[index + 1] |= USB_FUNCTION_BFREON;
}
#endif
}
/* Interrupt Disable */
buf = USB200.BRDYENB;
buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
USB200.BRDYENB = buf;
buf = USB200.NRDYENB;
buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
USB200.NRDYENB = buf;
buf = USB200.BEMPENB;
buf &= (uint16_t)~g_usb0_function_bit_set[pipe];
USB200.BEMPENB = buf;
usb0_function_set_pid_nak(pipe);
/* CurrentPIPE Clear */
if (RZA_IO_RegRead_16(&USB200.CFIFOSEL,
USB_CFIFOSEL_CURPIPE_SHIFT,
USB_CFIFOSEL_CURPIPE) == pipe)
{
RZA_IO_RegWrite_16(&USB200.CFIFOSEL,
0,
USB_CFIFOSEL_CURPIPE_SHIFT,
USB_CFIFOSEL_CURPIPE);
}
if (RZA_IO_RegRead_16(&USB200.D0FIFOSEL,
USB_DnFIFOSEL_CURPIPE_SHIFT,
USB_DnFIFOSEL_CURPIPE) == pipe)
{
RZA_IO_RegWrite_16(&USB200.D0FIFOSEL,
0,
USB_DnFIFOSEL_CURPIPE_SHIFT,
USB_DnFIFOSEL_CURPIPE);
}
if (RZA_IO_RegRead_16(&USB200.D1FIFOSEL,
USB_DnFIFOSEL_CURPIPE_SHIFT,
USB_DnFIFOSEL_CURPIPE) == pipe)
{
RZA_IO_RegWrite_16(&USB200.D1FIFOSEL,
0,
USB_DnFIFOSEL_CURPIPE_SHIFT,
USB_DnFIFOSEL_CURPIPE);
}
/* PIPE Configuration */
USB200.PIPESEL = pipe;
USB200.PIPECFG = tbl[index + 1];
USB200.PIPEBUF = tbl[index + 2];
USB200.PIPEMAXP = tbl[index + 3];
USB200.PIPEPERI = tbl[index + 4];
g_usb0_function_pipecfg[pipe] = tbl[index + 1];
g_usb0_function_pipebuf[pipe] = tbl[index + 2];
g_usb0_function_pipemaxp[pipe] = tbl[index + 3];
g_usb0_function_pipeperi[pipe] = tbl[index + 4];
/* Buffer Clear */
usb0_function_set_sqclr(pipe);
usb0_function_aclrm(pipe);
/* init Global */
g_usb0_function_pipe_status[pipe] = DEVDRV_USBF_PIPE_IDLE;
g_usb0_function_PipeDataSize[pipe] = 0;
}
}
}
#endif
/*******************************************************************************
* Function Name: usb0_function_EpToPipe
* Description : Returns the pipe which end point specified by the argument is
* : allocated to.
* Arguments : uint16_t ep ; Direction + Endpoint Number
* Return Value : USB_FUNCTION_EP_ERROR : Error
* : Others : Pipe Number
*******************************************************************************/
uint16_t usb0_function_EpToPipe (uint16_t ep)
{
uint16_t pipe;
for (pipe = 1; pipe <= USB_FUNCTION_MAX_PIPE_NO; pipe++)
{
if ((g_usb0_function_PipeTbl[pipe] & 0x00ff) == ep)
{
return pipe;
}
}
return USB_FUNCTION_EP_ERROR;
}
/*******************************************************************************
* Function Name: usb0_function_InitEPTable
* Description : Sets the end point by the Alternate setting value of the
* : configuration number and the interface number specified by the
* : argument.
* Arguments : uint16_t Con_Num ; Configuration Number
* : uint16_t Int_Num ; Interface Number
* : uint16_t Alt_Num ; Alternate Setting
* Return Value : none
*******************************************************************************/
#if 0
void usb0_function_InitEPTable (uint16_t Con_Num, uint16_t Int_Num, uint16_t Alt_Num)
{
uint8_t * ptr;
uint16_t point_interface;
uint16_t point_endpoint;
uint16_t length;
uint16_t start;
uint16_t numbers;
uint16_t endpoint;
ptr = (uint8_t *)g_usb0_function_ConfigurationPtr[Con_Num - 1];
point_interface = *ptr;
length = (uint16_t)((uint16_t)*(ptr + 3) << 8 | (uint16_t)*(ptr + 2));
ptr += *ptr;
start = 0;
numbers = 0;
point_endpoint = 0;
for (; point_interface < length;)
{
switch (*(ptr + 1)) /* Descriptor Type ? */
{
case USB_FUNCTION_DT_INTERFACE: /* Interface */
if ((*(ptr + 2) == Int_Num) && (*(ptr + 3) == Alt_Num))
{
numbers = *(ptr + 4);
}
else
{
start += *(ptr + 4);
}
point_interface += *ptr;
ptr += *ptr;
break;
case USB_FUNCTION_DT_ENDPOINT: /* Endpoint */
if (point_endpoint < numbers)
{
endpoint = (uint16_t)(*(ptr + 2) & 0x0f);
g_usb0_function_EPTableIndex[endpoint] = (uint16_t)(start + point_endpoint);
++point_endpoint;
}
point_interface += *ptr;
ptr += *ptr;
break;
case USB_FUNCTION_DT_DEVICE: /* Device */
case USB_FUNCTION_DT_CONFIGURATION: /* Configuration */
case USB_FUNCTION_DT_STRING: /* String */
default: /* Class, Vendor, else */
point_interface += *ptr;
ptr += *ptr;
break;
}
}
}
#endif
/*******************************************************************************
* Function Name: usb0_function_GetConfigNum
* Description : Returns the number of configuration referring to the number of
* : configuration described in the device descriptor.
* Arguments : none
* Return Value : Number of possible configurations (bNumConfigurations).
*******************************************************************************/
#if 0
uint16_t usb0_function_GetConfigNum (void)
{
return (uint16_t)g_usb0_function_DeviceDescriptor[17];
}
#endif
/*******************************************************************************
* Function Name: usb0_function_GetInterfaceNum
* Description : Returns the number of interface referring to the number of
* : interface described in the configuration descriptor.
* Arguments : uint16_t num ; Configuration Number
* Return Value : Number of this interface (bNumInterfaces).
*******************************************************************************/
#if 0
uint16_t usb0_function_GetInterfaceNum (uint16_t num)
{
return (uint16_t)(*(g_usb0_function_ConfigurationPtr[num - 1] + 4));
}
#endif
/*******************************************************************************
* Function Name: usb0_function_GetAltNum
* Description : Returns the Alternate setting value of the configuration number
* : and the interface number specified by the argument.
* Arguments : uint16_t Con_Num ; Configuration Number
* : uint16_t Int_Num ; Interface Number
* Return Value : Value used to select this alternate setting(bAlternateSetting).
*******************************************************************************/
#if 0
uint16_t usb0_function_GetAltNum (uint16_t Con_Num, uint16_t Int_Num)
{
uint8_t * ptr;
uint16_t point;
uint16_t alt_num = 0;
uint16_t length;
ptr = (uint8_t *)(g_usb0_function_ConfigurationPtr[Con_Num - 1]);
point = ptr[0];
ptr += ptr[0]; /* InterfaceDescriptor[0] */
length = (uint16_t)(*(g_usb0_function_ConfigurationPtr[Con_Num - 1] + 2));
length |= (uint16_t)((uint16_t)(*(g_usb0_function_ConfigurationPtr[Con_Num - 1] + 3)) << 8);
for (; point < length;) /* Search Descriptor Table size */
{
switch (ptr[1]) /* Descriptor Type ? */
{
case USB_FUNCTION_DT_INTERFACE: /* Interface */
if (Int_Num == ptr[2])
{
alt_num = (uint16_t)ptr[3]; /* Alternate Number count */
}
point += ptr[0];
ptr += ptr[0];
break;
case USB_FUNCTION_DT_DEVICE: /* Device */
case USB_FUNCTION_DT_CONFIGURATION: /* Configuration */
case USB_FUNCTION_DT_STRING: /* String */
case USB_FUNCTION_DT_ENDPOINT: /* Endpoint */
default: /* Class, Vendor, else */
point += ptr[0];
ptr += ptr[0];
break;
}
}
return alt_num;
}
#endif
/*******************************************************************************
* Function Name: usb0_function_CheckRemoteWakeup
* Description : Returns the result of the remote wake up function is supported
* : or not referring to the configuration descriptor.
* Arguments : none
* Return Value : DEVDRV_USBF_ON : Support Remote Wakeup
* : DEVDRV_USBF_OFF : not Support Remote Wakeup
*******************************************************************************/
#if 0
uint16_t usb0_function_CheckRemoteWakeup (void)
{
uint8_t atr;
if (g_usb0_function_ConfigNum == 0)
{
return DEVDRV_USBF_OFF;
}
atr = *(g_usb0_function_ConfigurationPtr[g_usb0_function_ConfigNum - 1] + 7);
if (atr & USB_FUNCTION_CF_RWUP)
{
return DEVDRV_USBF_ON;
}
return DEVDRV_USBF_OFF;
}
#endif
/*******************************************************************************
* Function Name: usb0_function_clear_alt
* Description : Initializes the Alternate setting area.
* Arguments : none
* Return Value : none
*******************************************************************************/
#if 0
void usb0_function_clear_alt (void)
{
int i;
for (i = 0; i < USB_FUNCTION_ALT_NO; ++i)
{
g_usb0_function_Alternate[i] = 0; /* Alternate */
}
}
#endif
/*******************************************************************************
* Function Name: usb0_function_clear_pipe_tbl
* Description : Initializes pipe definition table.
* Arguments : none
* Return Value : none
*******************************************************************************/
void usb0_function_clear_pipe_tbl (void)
{
int pipe;
for (pipe = 0; pipe < (USB_FUNCTION_MAX_PIPE_NO + 1); ++pipe)
{
g_usb0_function_PipeTbl[pipe] = 0;
}
}
/*******************************************************************************
* Function Name: usb0_function_clear_ep_table_index
* Description : Initializes the end point table index.
* Arguments : none
* Return Value : none
*******************************************************************************/
#if 0
void usb0_function_clear_ep_table_index (void)
{
int ep;
for (ep = 0; ep <= USB_FUNCTION_MAX_EP_NO; ++ep)
{
g_usb0_function_EPTableIndex[ep] = USB_FUNCTION_EP_ERROR;
}
}
#endif
/* End of File */

698
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_dmacdrv.c Normal file
View file

@ -0,0 +1,698 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_dmacdrv.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include <stdio.h>
#include "r_typedefs.h"
#include "iodefine.h"
#include "rza_io_regrw.h"
#include "usb0_function_dmacdrv.h"
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
#define DMAC_INDEFINE (255) /* Macro definition when REQD bit is not used */
/* ==== Request setting information for on-chip peripheral module ==== */
typedef enum dmac_peri_req_reg_type
{
DMAC_REQ_MID,
DMAC_REQ_RID,
DMAC_REQ_AM,
DMAC_REQ_LVL,
DMAC_REQ_REQD
} dmac_peri_req_reg_type_t;
/*******************************************************************************
Imported global variables and functions (from other files)
*******************************************************************************/
/*******************************************************************************
Exported global variables and functions (to be accessed by other files)
*******************************************************************************/
/*******************************************************************************
Private global variables and functions
*******************************************************************************/
/* ==== Prototype declaration ==== */
/* ==== Global variable ==== */
/* On-chip peripheral module request setting table */
static const uint8_t usb0_function_dmac_peri_req_init_table[8][5] =
{
/* MID,RID,AM,LVL,REQD */
{32, 3, 2, 1, 1}, /* USB_0 channel 0 transmit FIFO empty */
{32, 3, 2, 1, 0}, /* USB_0 channel 0 receive FIFO full */
{33, 3, 2, 1, 1}, /* USB_0 channel 1 transmit FIFO empty */
{33, 3, 2, 1, 0}, /* USB_0 channel 1 receive FIFO full */
{34, 3, 2, 1, 1}, /* USB_1 channel 0 transmit FIFO empty */
{34, 3, 2, 1, 0}, /* USB_1 channel 0 receive FIFO full */
{35, 3, 2, 1, 1}, /* USB_1 channel 1 transmit FIFO empty */
{35, 3, 2, 1, 0}, /* USB_1 channel 1 receive FIFO full */
};
/*******************************************************************************
* Function Name: usb0_function_DMAC1_PeriReqInit
* Description : Sets the register mode for DMA mode and the on-chip peripheral
* : module request for transfer request for DMAC channel 1.
* : Executes DMAC initial setting using the DMA information
* : specified by the argument *trans_info and the enabled/disabled
* : continuous transfer specified by the argument continuation.
* : Registers DMAC channel 1 interrupt handler function and sets
* : the interrupt priority level. Then enables transfer completion
* : interrupt.
* Arguments : dmac_transinfo_t *trans_info : Setting information to DMAC register
* : uint32_t dmamode : DMA mode (only for DMAC_MODE_REGISTER)
* : uint32_t continuation : Set continuous transfer to be valid
* : after DMA transfer has been completed
* : DMAC_SAMPLE_CONTINUATION : Execute continuous transfer
* : DMAC_SAMPLE_SINGLE : Do not execute continuous transfer
* : uint32_t request_factor : Factor for on-chip peripheral module request
* : DMAC_REQ_OSTM0TINT : OSTM_0 compare match
* : DMAC_REQ_OSTM1TINT : OSTM_1 compare match
* : DMAC_REQ_TGI0A : MTU2_0 input capture/compare match
* : :
* : uint32_t req_direction: Setting value of CHCFG_n register REQD bit
* Return Value : none
*******************************************************************************/
void usb0_function_DMAC1_PeriReqInit (const dmac_transinfo_t * trans_info,
uint32_t dmamode, uint32_t continuation,
uint32_t request_factor, uint32_t req_direction)
{
/* ==== Register mode ==== */
if (DMAC_MODE_REGISTER == dmamode)
{
/* ==== Next0 register set ==== */
DMAC1.N0SA_n = trans_info->src_addr; /* Start address of transfer source */
DMAC1.N0DA_n = trans_info->dst_addr; /* Start address of transfer destination */
DMAC1.N0TB_n = trans_info->count; /* Total transfer byte count */
/* DAD : Transfer destination address counting direction */
/* SAD : Transfer source address counting direction */
/* DDS : Transfer destination transfer size */
/* SDS : Transfer source transfer size */
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
trans_info->daddr_dir,
DMAC1_CHCFG_n_DAD_SHIFT,
DMAC1_CHCFG_n_DAD);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
trans_info->saddr_dir,
DMAC1_CHCFG_n_SAD_SHIFT,
DMAC1_CHCFG_n_SAD);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
trans_info->dst_size,
DMAC1_CHCFG_n_DDS_SHIFT,
DMAC1_CHCFG_n_DDS);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
trans_info->src_size,
DMAC1_CHCFG_n_SDS_SHIFT,
DMAC1_CHCFG_n_SDS);
/* DMS : Register mode */
/* RSEL : Select Next0 register set */
/* SBE : No discharge of buffer data when aborted */
/* DEM : No DMA interrupt mask */
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_DMS_SHIFT,
DMAC1_CHCFG_n_DMS);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_RSEL_SHIFT,
DMAC1_CHCFG_n_RSEL);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_SBE_SHIFT,
DMAC1_CHCFG_n_SBE);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_DEM_SHIFT,
DMAC1_CHCFG_n_DEM);
/* ---- Continuous transfer ---- */
if (DMAC_SAMPLE_CONTINUATION == continuation)
{
/* REN : Execute continuous transfer */
/* RSW : Change register set when DMA transfer is completed. */
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
1,
DMAC1_CHCFG_n_REN_SHIFT,
DMAC1_CHCFG_n_REN);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
1,
DMAC1_CHCFG_n_RSW_SHIFT,
DMAC1_CHCFG_n_RSW);
}
/* ---- Single transfer ---- */
else
{
/* REN : Do not execute continuous transfer */
/* RSW : Do not change register set when DMA transfer is completed. */
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_REN_SHIFT,
DMAC1_CHCFG_n_REN);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_RSW_SHIFT,
DMAC1_CHCFG_n_RSW);
}
/* TM : Single transfer */
/* SEL : Channel setting */
/* HIEN, LOEN : On-chip peripheral module request */
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_TM_SHIFT,
DMAC1_CHCFG_n_TM);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
1,
DMAC1_CHCFG_n_SEL_SHIFT,
DMAC1_CHCFG_n_SEL);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
1,
DMAC1_CHCFG_n_HIEN_SHIFT,
DMAC1_CHCFG_n_HIEN);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
0,
DMAC1_CHCFG_n_LOEN_SHIFT,
DMAC1_CHCFG_n_LOEN);
/* ---- Set factor by specified on-chip peripheral module request ---- */
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM],
DMAC1_CHCFG_n_AM_SHIFT,
DMAC1_CHCFG_n_AM);
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL],
DMAC1_CHCFG_n_LVL_SHIFT,
DMAC1_CHCFG_n_LVL);
if (usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE)
{
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD],
DMAC1_CHCFG_n_REQD_SHIFT,
DMAC1_CHCFG_n_REQD);
}
else
{
RZA_IO_RegWrite_32(&DMAC1.CHCFG_n,
req_direction,
DMAC1_CHCFG_n_REQD_SHIFT,
DMAC1_CHCFG_n_REQD);
}
RZA_IO_RegWrite_32(&DMAC01.DMARS,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID],
DMAC01_DMARS_CH1_RID_SHIFT,
DMAC01_DMARS_CH1_RID);
RZA_IO_RegWrite_32(&DMAC01.DMARS,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID],
DMAC01_DMARS_CH1_MID_SHIFT,
DMAC01_DMARS_CH1_MID);
/* PR : Round robin mode */
RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7,
1,
DMAC07_DCTRL_0_7_PR_SHIFT,
DMAC07_DCTRL_0_7_PR);
}
}
/*******************************************************************************
* Function Name: usb0_function_DMAC1_Open
* Description : Enables DMAC channel 1 transfer.
* Arguments : uint32_t req : DMAC request mode
* Return Value : 0 : Succeeded in enabling DMA transfer
* : -1 : Failed to enable DMA transfer (due to DMA operation)
*******************************************************************************/
int32_t usb0_function_DMAC1_Open (uint32_t req)
{
int32_t ret;
volatile uint8_t dummy;
/* Transferable? */
if ((0 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
DMAC1_CHSTAT_n_EN_SHIFT,
DMAC1_CHSTAT_n_EN)) &&
(0 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
DMAC1_CHSTAT_n_TACT_SHIFT,
DMAC1_CHSTAT_n_TACT)))
{
/* Clear Channel Status Register */
RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
1,
DMAC1_CHCTRL_n_SWRST_SHIFT,
DMAC1_CHCTRL_n_SWRST);
dummy = RZA_IO_RegRead_32(&DMAC1.CHCTRL_n,
DMAC1_CHCTRL_n_SWRST_SHIFT,
DMAC1_CHCTRL_n_SWRST);
/* Enable DMA transfer */
RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
1,
DMAC1_CHCTRL_n_SETEN_SHIFT,
DMAC1_CHCTRL_n_SETEN);
/* ---- Request by software ---- */
if (DMAC_REQ_MODE_SOFT == req)
{
/* DMA transfer Request by software */
RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
1,
DMAC1_CHCTRL_n_STG_SHIFT,
DMAC1_CHCTRL_n_STG);
}
ret = 0;
}
else
{
ret = -1;
}
return ret;
}
/*******************************************************************************
* Function Name: usb0_function_DMAC1_Close
* Description : Aborts DMAC channel 1 transfer. Returns the remaining transfer
* : byte count at the time of DMA transfer abort to the argument
* : *remain.
* Arguments : uint32_t * remain : Remaining transfer byte count when
* : : DMA transfer is aborted
* Return Value : none
*******************************************************************************/
void usb0_function_DMAC1_Close (uint32_t * remain)
{
/* ==== Abort transfer ==== */
RZA_IO_RegWrite_32(&DMAC1.CHCTRL_n,
1,
DMAC1_CHCTRL_n_CLREN_SHIFT,
DMAC1_CHCTRL_n_CLREN);
while (1 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
DMAC1_CHSTAT_n_TACT_SHIFT,
DMAC1_CHSTAT_n_TACT))
{
/* Loop until transfer is aborted */
}
while (1 == RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
DMAC1_CHSTAT_n_EN_SHIFT,
DMAC1_CHSTAT_n_EN))
{
/* Loop until 0 is set in EN before checking the remaining transfer byte count */
}
/* ==== Obtain remaining transfer byte count ==== */
*remain = DMAC1.CRTB_n;
}
/*******************************************************************************
* Function Name: usb0_function_DMAC1_Load_Set
* Description : Sets the transfer source address, transfer destination
* : address, and total transfer byte count respectively
* : specified by the argument src_addr, dst_addr, and count to
* : DMAC channel 1 as DMA transfer information.
* : Sets the register set selected by the CHCFG_n register
* : RSEL bit from the Next0 or Next1 register set.
* : This function should be called when DMA transfer of DMAC
* : channel 1 is aboted.
* Arguments : uint32_t src_addr : Transfer source address
* : uint32_t dst_addr : Transfer destination address
* : uint32_t count : Total transfer byte count
* Return Value : none
*******************************************************************************/
void usb0_function_DMAC1_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count)
{
uint8_t reg_set;
/* Obtain register set in use */
reg_set = RZA_IO_RegRead_32(&DMAC1.CHSTAT_n,
DMAC1_CHSTAT_n_SR_SHIFT,
DMAC1_CHSTAT_n_SR);
/* ==== Load ==== */
if (0 == reg_set)
{
/* ---- Next0 Register Set ---- */
DMAC1.N0SA_n = src_addr; /* Start address of transfer source */
DMAC1.N0DA_n = dst_addr; /* Start address of transfer destination */
DMAC1.N0TB_n = count; /* Total transfer byte count */
}
else
{
/* ---- Next1 Register Set ---- */
DMAC1.N1SA_n = src_addr; /* Start address of transfer source */
DMAC1.N1DA_n = dst_addr; /* Start address of transfer destination */
DMAC1.N1TB_n = count; /* Total transfer byte count */
}
}
/*******************************************************************************
* Function Name: usb0_function_DMAC2_PeriReqInit
* Description : Sets the register mode for DMA mode and the on-chip peripheral
* : module request for transfer request for DMAC channel 2.
* : Executes DMAC initial setting using the DMA information
* : specified by the argument *trans_info and the enabled/disabled
* : continuous transfer specified by the argument continuation.
* : Registers DMAC channel 2 interrupt handler function and sets
* : the interrupt priority level. Then enables transfer completion
* : interrupt.
* Arguments : dmac_transinfo_t * trans_info : Setting information to DMAC
* : : register
* : uint32_t dmamode : DMA mode (only for DMAC_MODE_REGISTER)
* : uint32_t continuation : Set continuous transfer to be valid
* : : after DMA transfer has been completed
* : DMAC_SAMPLE_CONTINUATION : Execute continuous transfer
* : DMAC_SAMPLE_SINGLE : Do not execute continuous
* : : transfer
* : uint32_t request_factor : Factor for on-chip peripheral module
* : : request
* : DMAC_REQ_OSTM0TINT : OSTM_0 compare match
* : DMAC_REQ_OSTM1TINT : OSTM_1 compare match
* : DMAC_REQ_TGI0A : MTU2_0 input capture/compare match
* : :
* : uint32_t req_direction : Setting value of CHCFG_n register
* : : REQD bit
*******************************************************************************/
void usb0_function_DMAC2_PeriReqInit (const dmac_transinfo_t * trans_info,
uint32_t dmamode, uint32_t continuation,
uint32_t request_factor, uint32_t req_direction)
{
/* ==== Register mode ==== */
if (DMAC_MODE_REGISTER == dmamode)
{
/* ==== Next0 register set ==== */
DMAC2.N0SA_n = trans_info->src_addr; /* Start address of transfer source */
DMAC2.N0DA_n = trans_info->dst_addr; /* Start address of transfer destination */
DMAC2.N0TB_n = trans_info->count; /* Total transfer byte count */
/* DAD : Transfer destination address counting direction */
/* SAD : Transfer source address counting direction */
/* DDS : Transfer destination transfer size */
/* SDS : Transfer source transfer size */
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
trans_info->daddr_dir,
DMAC2_CHCFG_n_DAD_SHIFT,
DMAC2_CHCFG_n_DAD);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
trans_info->saddr_dir,
DMAC2_CHCFG_n_SAD_SHIFT,
DMAC2_CHCFG_n_SAD);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
trans_info->dst_size,
DMAC2_CHCFG_n_DDS_SHIFT,
DMAC2_CHCFG_n_DDS);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
trans_info->src_size,
DMAC2_CHCFG_n_SDS_SHIFT,
DMAC2_CHCFG_n_SDS);
/* DMS : Register mode */
/* RSEL : Select Next0 register set */
/* SBE : No discharge of buffer data when aborted */
/* DEM : No DMA interrupt mask */
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_DMS_SHIFT,
DMAC2_CHCFG_n_DMS);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_RSEL_SHIFT,
DMAC2_CHCFG_n_RSEL);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_SBE_SHIFT,
DMAC2_CHCFG_n_SBE);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_DEM_SHIFT,
DMAC2_CHCFG_n_DEM);
/* ---- Continuous transfer ---- */
if (DMAC_SAMPLE_CONTINUATION == continuation)
{
/* REN : Execute continuous transfer */
/* RSW : Change register set when DMA transfer is completed. */
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
1,
DMAC2_CHCFG_n_REN_SHIFT,
DMAC2_CHCFG_n_REN);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
1,
DMAC2_CHCFG_n_RSW_SHIFT,
DMAC2_CHCFG_n_RSW);
}
/* ---- Single transfer ---- */
else
{
/* REN : Do not execute continuous transfer */
/* RSW : Do not change register set when DMA transfer is completed. */
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_REN_SHIFT,
DMAC2_CHCFG_n_REN);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_RSW_SHIFT,
DMAC2_CHCFG_n_RSW);
}
/* TM : Single transfer */
/* SEL : Channel setting */
/* HIEN, LOEN : On-chip peripheral module request */
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_TM_SHIFT,
DMAC2_CHCFG_n_TM);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
2,
DMAC2_CHCFG_n_SEL_SHIFT,
DMAC2_CHCFG_n_SEL);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
1,
DMAC2_CHCFG_n_HIEN_SHIFT,
DMAC2_CHCFG_n_HIEN);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
0,
DMAC2_CHCFG_n_LOEN_SHIFT,
DMAC2_CHCFG_n_LOEN);
/* ---- Set factor by specified on-chip peripheral module request ---- */
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_AM],
DMAC2_CHCFG_n_AM_SHIFT,
DMAC2_CHCFG_n_AM);
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_LVL],
DMAC2_CHCFG_n_LVL_SHIFT,
DMAC2_CHCFG_n_LVL);
if (usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD] != DMAC_INDEFINE)
{
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_REQD],
DMAC2_CHCFG_n_REQD_SHIFT,
DMAC2_CHCFG_n_REQD);
}
else
{
RZA_IO_RegWrite_32(&DMAC2.CHCFG_n,
req_direction,
DMAC2_CHCFG_n_REQD_SHIFT,
DMAC2_CHCFG_n_REQD);
}
RZA_IO_RegWrite_32(&DMAC23.DMARS,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_RID],
DMAC23_DMARS_CH2_RID_SHIFT,
DMAC23_DMARS_CH2_RID);
RZA_IO_RegWrite_32(&DMAC23.DMARS,
usb0_function_dmac_peri_req_init_table[request_factor][DMAC_REQ_MID],
DMAC23_DMARS_CH2_MID_SHIFT,
DMAC23_DMARS_CH2_MID);
/* PR : Round robin mode */
RZA_IO_RegWrite_32(&DMAC07.DCTRL_0_7,
1,
DMAC07_DCTRL_0_7_PR_SHIFT,
DMAC07_DCTRL_0_7_PR);
}
}
/*******************************************************************************
* Function Name: usb0_function_DMAC2_Open
* Description : Enables DMAC channel 2 transfer.
* Arguments : uint32_t req : DMAC request mode
* Return Value : 0 : Succeeded in enabling DMA transfer
* : -1 : Failed to enable DMA transfer (due to DMA operation)
*******************************************************************************/
int32_t usb0_function_DMAC2_Open (uint32_t req)
{
int32_t ret;
volatile uint8_t dummy;
/* Transferable? */
if ((0 == RZA_IO_RegRead_32(&DMAC.CHSTAT_2,
DMAC2_CHSTAT_n_EN_SHIFT,
DMAC2_CHSTAT_n_EN)) &&
(0 == RZA_IO_RegRead_32(&DMAC.CHSTAT_2,
DMAC2_CHSTAT_n_TACT_SHIFT,
DMAC2_CHSTAT_n_TACT)))
{
/* Clear Channel Status Register */
RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
1,
DMAC2_CHCTRL_n_SWRST_SHIFT,
DMAC2_CHCTRL_n_SWRST);
dummy = RZA_IO_RegRead_32(&DMAC2.CHCTRL_n,
DMAC2_CHCTRL_n_SWRST_SHIFT,
DMAC2_CHCTRL_n_SWRST);
/* Enable DMA transfer */
RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
1,
DMAC2_CHCTRL_n_SETEN_SHIFT,
DMAC2_CHCTRL_n_SETEN);
/* ---- Request by software ---- */
if (DMAC_REQ_MODE_SOFT == req)
{
/* DMA transfer Request by software */
RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
1,
DMAC2_CHCTRL_n_STG_SHIFT,
DMAC2_CHCTRL_n_STG);
}
ret = 0;
}
else
{
ret = -1;
}
return ret;
}
/*******************************************************************************
* Function Name: usb0_function_DMAC2_Close
* Description : Aborts DMAC channel 2 transfer. Returns the remaining transfer
* : byte count at the time of DMA transfer abort to the argument
* : *remain.
* Arguments : uint32_t * remain : Remaining transfer byte count when
* : : DMA transfer is aborted
* Return Value : none
*******************************************************************************/
void usb0_function_DMAC2_Close (uint32_t * remain)
{
/* ==== Abort transfer ==== */
RZA_IO_RegWrite_32(&DMAC2.CHCTRL_n,
1,
DMAC2_CHCTRL_n_CLREN_SHIFT,
DMAC2_CHCTRL_n_CLREN);
while (1 == RZA_IO_RegRead_32(&DMAC2.CHSTAT_n,
DMAC2_CHSTAT_n_TACT_SHIFT,
DMAC2_CHSTAT_n_TACT))
{
/* Loop until transfer is aborted */
}
while (1 == RZA_IO_RegRead_32(&DMAC2.CHSTAT_n,
DMAC2_CHSTAT_n_EN_SHIFT,
DMAC2_CHSTAT_n_EN))
{
/* Loop until 0 is set in EN before checking the remaining transfer byte count */
}
/* ==== Obtain remaining transfer byte count ==== */
*remain = DMAC2.CRTB_n;
}
/*******************************************************************************
* Function Name: usb0_function_DMAC2_Load_Set
* Description : Sets the transfer source address, transfer destination
* : address, and total transfer byte count respectively
* : specified by the argument src_addr, dst_addr, and count to
* : DMAC channel 2 as DMA transfer information.
* : Sets the register set selected by the CHCFG_n register
* : RSEL bit from the Next0 or Next1 register set.
* : This function should be called when DMA transfer of DMAC
* : channel 2 is aboted.
* Arguments : uint32_t src_addr : Transfer source address
* : uint32_t dst_addr : Transfer destination address
* : uint32_t count : Total transfer byte count
* Return Value : none
*******************************************************************************/
void usb0_function_DMAC2_Load_Set (uint32_t src_addr, uint32_t dst_addr, uint32_t count)
{
uint8_t reg_set;
/* Obtain register set in use */
reg_set = RZA_IO_RegRead_32(&DMAC2.CHSTAT_n,
DMAC2_CHSTAT_n_SR_SHIFT,
DMAC2_CHSTAT_n_SR);
/* ==== Load ==== */
if (0 == reg_set)
{
/* ---- Next0 Register Set ---- */
DMAC2.N0SA_n = src_addr; /* Start address of transfer source */
DMAC2.N0DA_n = dst_addr; /* Start address of transfer destination */
DMAC2.N0TB_n = count; /* Total transfer byte count */
}
else
{
/* ---- Next1 Register Set ---- */
DMAC2.N1SA_n = src_addr; /* Start address of transfer source */
DMAC2.N1DA_n = dst_addr; /* Start address of transfer destination */
DMAC2.N1TB_n = count; /* Total transfer byte count */
}
}
/* End of File */

762
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_userdef.c Normal file
View file

@ -0,0 +1,762 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : usb0_function_userdef.c
* $Rev: 1116 $
* $Date:: 2014-07-09 16:29:19 +0900#$
* Device(s) : RZ/A1H
* Tool-Chain :
* OS : None
* H/W Platform :
* Description : RZ/A1H R7S72100 USB Sample Program
* Operation :
* Limitations :
*******************************************************************************/
/*******************************************************************************
Includes <System Includes> , "Project Includes"
*******************************************************************************/
#include <stdio.h>
#include "r_typedefs.h"
#include "iodefine.h"
#include "devdrv_usb_function_api.h"
#include "usb0_function_dmacdrv.h" /* common DMAC driver for USB */
/*******************************************************************************
Typedef definitions
*******************************************************************************/
/*******************************************************************************
Macro definitions
*******************************************************************************/
#define DUMMY_ACCESS 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 */

171
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function.h Normal file
View file

@ -0,0 +1,171 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

104
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_api.h Normal file
View file

@ -0,0 +1,104 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

142
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_dmacdrv.h Normal file
View file

@ -0,0 +1,142 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

2932
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dataio.c Normal file
View file

File diff suppressed because it is too large Load diff

346
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dma.c Normal file
View file

@ -0,0 +1,346 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

249
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_intrn.c Normal file
View file

@ -0,0 +1,249 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

2044
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_lib.c Normal file
View file

File diff suppressed because it is too large Load diff

441
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_api.c Normal file
View file

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

142
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_controlrw.c Normal file
View file

@ -0,0 +1,142 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

144
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_global.c Normal file
View file

@ -0,0 +1,144 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

330
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sig.c Normal file
View file

@ -0,0 +1,330 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

453
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sub.c Normal file
View file

@ -0,0 +1,453 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

698
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_dmacdrv.c Normal file
View file

@ -0,0 +1,698 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

762
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_userdef.c Normal file
View file

@ -0,0 +1,762 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright (C) 2012 - 2014 Renesas Electronics Corporation. All rights reserved.
*******************************************************************************/
/*******************************************************************************
* File Name : 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 */

173
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb_function_setting.h Normal file
View file

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

74
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDescriptor.h Normal file
View file

@ -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)

1005
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.cpp Normal file
View file

File diff suppressed because it is too large Load diff

271
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.h Normal file
View file

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

83
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice_Types.h Normal file
View file

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

56
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints.h Normal file
View file

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

99
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_KL25Z.h Normal file
View file

@ -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)

71
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC11U.h Normal file
View file

@ -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)

99
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC17_LPC23.h Normal file
View file

@ -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)

90
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_Maxim.h Normal file
View file

@ -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)

85
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h Normal file
View file

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

67
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_STM32F4.h Normal file
View file

@ -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)

121
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL.h Normal file
View file

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

551
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_KL25Z.cpp Normal file
View file

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

738
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC11U.cpp Normal file
View file

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

623
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC17.cpp Normal file
View file

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

628
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC40.cpp Normal file
View file

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

473
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp Normal file
View file

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

1497
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp Normal file
View file

File diff suppressed because it is too large Load diff

410
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_STM32F4.cpp Normal file
View file

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

149
tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBRegs_STM32.h Normal file
View file

@ -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>&copy; 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****/

276
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.cpp Normal file
View file

@ -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;
}

172
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.h Normal file
View file

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

91
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID_Types.h Normal file
View file

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

553
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.cpp Normal file
View file

@ -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;
}

183
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.h Normal file
View file

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

245
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.cpp Normal file
View file

@ -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;
}

209
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.h Normal file
View file

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

706
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.cpp Normal file
View file

@ -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);
}

220
tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.h Normal file
View file

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

276
tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/MIDIMessage.h Normal file
View file

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

207
tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.cpp Normal file
View file

@ -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;
}

112
tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.h Normal file
View file

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

655
tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.cpp Normal file
View file

@ -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;
}

251
tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.h Normal file
View file

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

63
tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/CircBuffer.h Normal file
View file

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

286
tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.cpp Normal file
View file

@ -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;
}

123
tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.h Normal file
View file

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

67
tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.cpp Normal file
View file

@ -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();
}

161
tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.h Normal file
View file

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