9 years ago · a3d96d3aa9
--- a/tmk_core/tool/mbed/mbed-sdk/.gitattributes
+++ b/tmk_core/tool/mbed/mbed-sdk/.gitattributes
@@ -0,0 +1,15 @@
 *.c text
 *.cpp text
 *.h text
 *.s text
 *.sct text
 *.ld text
 *.txt text
 *.xml text
 *.py text
 *.md text
 *.json text
 *.tmpl text
 *.dia binary
 *.elf binary
 *.bin binary
--- a/tmk_core/tool/mbed/mbed-sdk/.gitignore
+++ b/tmk_core/tool/mbed/mbed-sdk/.gitignore
@@ -0,0 +1,75 @@
 *.py[cod]

 # Distribution dir
 dist

 # MANIFEST file
 MANIFEST

 # Private settings
 private_settings.py

 # Default Build Directory
 build/

 # Eclipse Project Files
 .cproject
 .project
 .pydevproject

 # C extensions
 *.so

 # Packages
 *.egg
 *.egg-info
 dist
 build
 eggs
 parts
 bin
 var
 sdist
 develop-eggs
 .installed.cfg
 lib
 lib64

 # Installer logs
 pip-log.txt

 # Unit test / coverage reports
 .coverage
 .tox
 nosetests.xml

 # Translations
 *.mo

 # Mr Developer
 .mr.developer.cfg

 output.txt
 uVision Project/

 # Sublime Text Project Files
 *.sublime*

 *.bak
 debug.log

 # Ignore OS X Desktop Services Store files
 .DS_Store

 # Orig diff files
 *.orig

 # PyCharm
 *.idea

 # Cscope
 cscope.*

 # vim swap files
 *.swp

--- a/tmk_core/tool/mbed/mbed-sdk/.travis.yml
+++ b/tmk_core/tool/mbed/mbed-sdk/.travis.yml
@@ -0,0 +1,9 @@
 ---
 python:
 - "2.7"
 script: "python workspace_tools/build_travis.py"
 install:
 - "sudo $TRAVIS_BUILD_DIR/travis/install_dependencies.sh > /dev/null"
 - sudo pip install colorama
 - sudo pip install prettytable
 - sudo pip install jinja2
--- a/tmk_core/tool/mbed/mbed-sdk/CONTRIBUTING.md
+++ b/tmk_core/tool/mbed/mbed-sdk/CONTRIBUTING.md
@@ -0,0 +1,45 @@
 # Description
 This document is cheat sheet for everyone who wants to contribute to mbedmicro/mbed GitHub repository at GitHub. 
 All changes in code base should originate from GitHub Issues and take advantage of existing GitHub flows. Goal is to attract contributors and allow them contribute to code and documentation at the same time.

 Guidelines from this document are created to help new and existing contributors understand process workflow and align to project rules before pull request is submitted. It explains how a participant should do things like format code, test fixes, and submit patches.

 ## Where to get more information?
 You can for example read more in our ```docs``` section in [mbedmicro/mbed/doc](https://github.com/PrzemekWirkus/mbed/tree/docs/docs) directory.

 # How to contribute
 We really appreciate your contributions! We are Open Source project and we need your help. We want to keep it as easy as possible to contribute changes that get things working in your environment. There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.

 Before a pull request will be merged, the [mbed Contributor Agreement](http://developer.mbed.org/contributor_agreement/) must be signed.

 You can pick up existing [mbed GitHub Issue](https://github.com/mbedmicro/mbed/issues) and solve it or implement new feature you find important, attractive or just necessary. We will review your proposal via pull request mechanism, give you comments and merge your changes if we decide your contribution satisfy criteria such as quality.

 # Enhancements vs Bugs
 Enhancements are:
 * New features implementation.
 * Code refactoring.
 * Coding rules, coding styles improvements.
 * Code comments improvement.
 * Documentation work.

 Bugs are:
 * Issues rose internally or externally by mbedmicro/mbed users.
 * Internally (within mbed team) created issues from Continuous Integration pipeline and build servers.
 * Issues detected using automation tools such as compilers, sanitizers, static code analysis tools etc.

 # Gate Keeper role
 Gate Keeper is a person responsible for GitHub process workflow execution and is responsible for repository / project code base. Gate Keeper is also responsible for code (pull request) quality stamp and approves or rejects code changes in project’s code base.

 Gate Keepers will review your pull request code, give you comments in pull request comment section and in the end if everything goes well merge your pull request to one of our branches (most probably default ```master``` branch).

 Please be patient, digest Gate Keeper's feedback and respond promptly :)

 # mbed SDK porting
 * For more information regarding mbed SDK porting please refer to [mbed SDK porting](http://developer.mbed.org/handbook/mbed-SDK-porting) handbook.
 * Before starting the mbed SDK porting, you might want to familiarize with the [mbed SDK library internals](http://developer.mbed.org/handbook/mbed-library-internals) first.

 # Glossary
 * Gate Keeper – persons responsible for overall code-base quality of mbedmicro/mbed project.
 * Enhancement – New feature deployment, code refactoring actions or existing code improvements.
 * Bugfix – Issues originated from GitHub Issues pool, raised internally within mbed classic team or issues from automated code validators like linters, static code analysis tools etc.
 * Mbed classic – mbed SDK 2.0 located in GitHub at mbedmicro/mbed.
--- a/tmk_core/tool/mbed/mbed-sdk/LICENSE
+++ b/tmk_core/tool/mbed/mbed-sdk/LICENSE
@@ -0,0 +1,165 @@
 Apache License
 Version 2.0, January 2004
 http://www.apache.org/licenses/

 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

 1. Definitions.

 "License" shall mean the terms and conditions for use, reproduction, and
 distribution as defined by Sections 1 through 9 of this document.

 "Licensor" shall mean the copyright owner or entity authorized by the copyright
 owner that is granting the License.

 "Legal Entity" shall mean the union of the acting entity and all other entities
 that control, are controlled by, or are under common control with that entity.
 For the purposes of this definition, "control" means (i) the power, direct or
 indirect, to cause the direction or management of such entity, whether by
 contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
 outstanding shares, or (iii) beneficial ownership of such entity.

 "You" (or "Your") shall mean an individual or Legal Entity exercising
 permissions granted by this License.

 "Source" form shall mean the preferred form for making modifications, including
 but not limited to software source code, documentation source, and configuration
 files.

 "Object" form shall mean any form resulting from mechanical transformation or
 translation of a Source form, including but not limited to compiled object code,
 generated documentation, and conversions to other media types.

 "Work" shall mean the work of authorship, whether in Source or Object form, made
 available under the License, as indicated by a copyright notice that is included
 in or attached to the work (an example is provided in the Appendix below).

 "Derivative Works" shall mean any work, whether in Source or Object form, that
 is based on (or derived from) the Work and for which the editorial revisions,
 annotations, elaborations, or other modifications represent, as a whole, an
 original work of authorship. For the purposes of this License, Derivative Works
 shall not include works that remain separable from, or merely link (or bind by
 name) to the interfaces of, the Work and Derivative Works thereof.

 "Contribution" shall mean any work of authorship, including the original version
 of the Work and any modifications or additions to that Work or Derivative Works
 thereof, that is intentionally submitted to Licensor for inclusion in the Work
 by the copyright owner or by an individual or Legal Entity authorized to submit
 on behalf of the copyright owner. For the purposes of this definition,
 "submitted" means any form of electronic, verbal, or written communication sent
 to the Licensor or its representatives, including but not limited to
 communication on electronic mailing lists, source code control systems, and
 issue tracking systems that are managed by, or on behalf of, the Licensor for
 the purpose of discussing and improving the Work, but excluding communication
 that is conspicuously marked or otherwise designated in writing by the copyright
 owner as "Not a Contribution."

 "Contributor" shall mean Licensor and any individual or Legal Entity on behalf
 of whom a Contribution has been received by Licensor and subsequently
 incorporated within the Work.

 2. Grant of Copyright License.

 Subject to the terms and conditions of this License, each Contributor hereby
 grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 irrevocable copyright license to reproduce, prepare Derivative Works of,
 publicly display, publicly perform, sublicense, and distribute the Work and such
 Derivative Works in Source or Object form.

 3. Grant of Patent License.

 Subject to the terms and conditions of this License, each Contributor hereby
 grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
 irrevocable (except as stated in this section) patent license to make, have
 made, use, offer to sell, sell, import, and otherwise transfer the Work, where
 such license applies only to those patent claims licensable by such Contributor
 that are necessarily infringed by their Contribution(s) alone or by combination
 of their Contribution(s) with the Work to which such Contribution(s) was
 submitted. If You institute patent litigation against any entity (including a
 cross-claim or counterclaim in a lawsuit) alleging that the Work or a
 Contribution incorporated within the Work constitutes direct or contributory
 patent infringement, then any patent licenses granted to You under this License
 for that Work shall terminate as of the date such litigation is filed.

 4. Redistribution.

 You may reproduce and distribute copies of the Work or Derivative Works thereof
 in any medium, with or without modifications, and in Source or Object form,
 provided that You meet the following conditions:

 You must give any other recipients of the Work or Derivative Works a copy of
 this License; and
 You must cause any modified files to carry prominent notices stating that You
 changed the files; and
 You must retain, in the Source form of any Derivative Works that You distribute,
 all copyright, patent, trademark, and attribution notices from the Source form
 of the Work, excluding those notices that do not pertain to any part of the
 Derivative Works; and
 If the Work includes a "NOTICE" text file as part of its distribution, then any
 Derivative Works that You distribute must include a readable copy of the
 attribution notices contained within such NOTICE file, excluding those notices
 that do not pertain to any part of the Derivative Works, in at least one of the
 following places: within a NOTICE text file distributed as part of the
 Derivative Works; within the Source form or documentation, if provided along
 with the Derivative Works; or, within a display generated by the Derivative
 Works, if and wherever such third-party notices normally appear. The contents of
 the NOTICE file are for informational purposes only and do not modify the
 License. You may add Your own attribution notices within Derivative Works that
 You distribute, alongside or as an addendum to the NOTICE text from the Work,
 provided that such additional attribution notices cannot be construed as
 modifying the License.
 You may add Your own copyright statement to Your modifications and may provide
 additional or different license terms and conditions for use, reproduction, or
 distribution of Your modifications, or for any such Derivative Works as a whole,
 provided Your use, reproduction, and distribution of the Work otherwise complies
 with the conditions stated in this License.

 5. Submission of Contributions.

 Unless You explicitly state otherwise, any Contribution intentionally submitted
 for inclusion in the Work by You to the Licensor shall be under the terms and
 conditions of this License, without any additional terms or conditions.
 Notwithstanding the above, nothing herein shall supersede or modify the terms of
 any separate license agreement you may have executed with Licensor regarding
 such Contributions.

 6. Trademarks.

 This License does not grant permission to use the trade names, trademarks,
 service marks, or product names of the Licensor, except as required for
 reasonable and customary use in describing the origin of the Work and
 reproducing the content of the NOTICE file.

 7. Disclaimer of Warranty.

 Unless required by applicable law or agreed to in writing, Licensor provides the
 Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
 including, without limitation, any warranties or conditions of TITLE,
 NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
 solely responsible for determining the appropriateness of using or
 redistributing the Work and assume any risks associated with Your exercise of
 permissions under this License.

 8. Limitation of Liability.

 In no event and under no legal theory, whether in tort (including negligence),
 contract, or otherwise, unless required by applicable law (such as deliberate
 and grossly negligent acts) or agreed to in writing, shall any Contributor be
 liable to You for damages, including any direct, indirect, special, incidental,
 or consequential damages of any character arising as a result of this License or
 out of the use or inability to use the Work (including but not limited to
 damages for loss of goodwill, work stoppage, computer failure or malfunction, or
 any and all other commercial damages or losses), even if such Contributor has
 been advised of the possibility of such damages.

 9. Accepting Warranty or Additional Liability.

 While redistributing the Work or Derivative Works thereof, You may choose to
 offer, and charge a fee for, acceptance of support, warranty, indemnity, or
 other liability obligations and/or rights consistent with this License. However,
 in accepting such obligations, You may act only on Your own behalf and on Your
 sole responsibility, not on behalf of any other Contributor, and only if You
 agree to indemnify, defend, and hold each Contributor harmless for any liability
 incurred by, or claims asserted against, such Contributor by reason of your
 accepting any such warranty or additional liability.
--- a/tmk_core/tool/mbed/mbed-sdk/MANIFEST.in
+++ b/tmk_core/tool/mbed/mbed-sdk/MANIFEST.in
@@ -0,0 +1,3 @@
 graft workspace_tools
 recursive-exclude workspace_tools *.pyc
 include LICENSE
--- a/tmk_core/tool/mbed/mbed-sdk/README.md
+++ b/tmk_core/tool/mbed/mbed-sdk/README.md
@@ -0,0 +1,115 @@
 mbed SDK
 ========

 [![Build Status](https://travis-ci.org/mbedmicro/mbed.png)](https://travis-ci.org/mbedmicro/mbed/builds)

 The mbed Software Development Kit (SDK) is a C/C++ microcontroller software platform relied upon by tens of thousands of
 developers to build projects fast.

 The SDK is licensed under the permissive Apache 2.0 licence, so you can use it in both commercial and personal projects
 with confidence.

 The mbed SDK has been designed to provide enough hardware abstraction to be intuitive and concise, yet powerful enough
 to build complex projects. It is built on the low-level ARM CMSIS APIs, allowing you to code down to the metal if needed.
 In addition to RTOS, USB and Networking libraries, a cookbook of hundreds of reusable peripheral and module libraries
 have been built on top of the SDK by the mbed Developer Community.

 Documentation
 -------------
 * [Tools](http://developer.mbed.org/handbook/mbed-tools): how to setup and use the build system.
 * [mbed library internals](http://developer.mbed.org/handbook/mbed-library-internals)
 * [Adding a new target microcontroller](http://developer.mbed.org/handbook/mbed-SDK-porting)

 Supported Microcontrollers and Boards
 -------------------------------------
 View all on the [mbed Platforms](https://developer.mbed.org/platforms/) page.

 NXP:
 * [mbed LPC1768](http://developer.mbed.org/platforms/mbed-LPC1768/) (Cortex-M3)
 * [u-blox C027 LPC1768](http://developer.mbed.org/platforms/u-blox-C027/) (Cortex-M3)
 * [mbed LPC11U24](http://developer.mbed.org/platforms/mbed-LPC11U24/) (Cortex-M0)
 * [EA LPC11U35](http://developer.mbed.org/platforms/EA-LPC11U35/) (Cortex-M0)
 * mbed LPC2368 (ARM7TDMI-S)
 * LPC810 (Cortex-M0+)
 * [LPC812](http://developer.mbed.org/platforms/NXP-LPC800-MAX/) (Cortex-M0+)
 * [EA LPC4088](http://developer.mbed.org/platforms/EA-LPC4088/) (Cortex-M4F)
 * [EA LPC4088 DM](http://developer.mbed.org/platforms/EA-LPC4088-Display-Module/) (Cortex-M4F)
 * LPC4330 (Cortex-M4F + Cortex-M0)
 * [LPC1347](http://developer.mbed.org/platforms/DipCortex-M3/) (Cortex-M3)
 * [LPC1114](http://developer.mbed.org/platforms/LPC1114FN28/) (Cortex-M0)
 * LPC11C24 (Cortex-M0)
 * [LPC1549](https://developer.mbed.org/platforms/LPCXpresso1549/) (Cortex-M3)
 * [LPC800-MAX](https://developer.mbed.org/platforms/NXP-LPC800-MAX/) (Cortex-M0+)
 * [DipCortex-M0](https://developer.mbed.org/platforms/DipCortex-M0/) (Cortex-M0)
 * [DipCortex-M3](https://developer.mbed.org/platforms/DipCortex-M3/) (Cortex-M3)
 * [BlueBoard-LPC11U24](https://developer.mbed.org/platforms/BlueBoard-LPC11U24/) (Cortex-M0)
 * LPCCAPPUCCINO (Cortex-M0)
 * [Arch](https://developer.mbed.org/platforms/Seeeduino-Arch/) (Cortex-M0)
 * [Arch GPRS](https://developer.mbed.org/platforms/Seeed-Arch-GPRS/) (Cortex-M0)
 * [Arch Pro](https://developer.mbed.org/platforms/Seeeduino-Arch-Pro/) (Cortex-M3)

 Freescale:
 * [FRDM-KL05Z](https://developer.mbed.org/platforms/FRDM-KL05Z/) (Cortex-M0+)
 * [FRDM-KL25Z](http://developer.mbed.org/platforms/KL25Z/) (Cortex-M0+)
 * FRDM-KL43Z (Cortex-M0+)
 * [FRDM-KL46Z](https://developer.mbed.org/platforms/FRDM-KL46Z/) (Cortex-M0+)
 * [FRDM-K20D50M](https://developer.mbed.org/platforms/FRDM-K20D50M/) (Cortex-M4)
 * [FRDM-K22F](https://developer.mbed.org/platforms/FRDM-K22F/) (Cortex-M4F)
 * [FRDM-K64F](https://developer.mbed.org/platforms/FRDM-K64F/) (Cortex-M4F)

 STMicroelectronics:
 * [Nucleo-F030R8](https://developer.mbed.org/platforms/ST-Nucleo-F030R8/) (Cortex-M0)
 * [Nucleo-F072RB](https://developer.mbed.org/platforms/ST-Nucleo-F072RB/) (Cortex-M0)
 * [Nucleo-L053R8](https://developer.mbed.org/platforms/ST-Nucleo-L053R8/) (Cortex-M0+)
 * [Nucleo-F103RB](https://developer.mbed.org/platforms/ST-Nucleo-F103RB/) (Cortex-M3)
 * [Nucleo-L152RE](https://developer.mbed.org/platforms/ST-Nucleo-L152RE/) (Cortex-M3)
 * [Nucleo-F302R8](https://developer.mbed.org/platforms/ST-Nucleo-F302R8/) (Cortex-M4F)
 * [Nucleo-F334R8](https://developer.mbed.org/platforms/ST-Nucleo-F334R8/) (Cortex-M4F)
 * [Nucleo-F401RE](https://developer.mbed.org/platforms/ST-Nucleo-F401RE/) (Cortex-M4F)
 * [Nucleo-F411RE](https://developer.mbed.org/platforms/ST-Nucleo-F411RE/) (Cortex-M4F)
 * STM32F4XX (Cortex-M4F)
 * STM32F3XX (Cortex-M4F)
 * STM32F0-Discovery (Cortex-M0)
 * STM32VL-Discovery (Cortex-M3)
 * STM32F3-Discovery (Cortex-M4F)
 * STM32F4-Discovery (Cortex-M4F)
 * STM32F429-Discovery (Cortex-M4F)
 * STM32L0-Discovery (Cortex-M0+)
 * [Arch Max](https://developer.mbed.org/platforms/Seeed-Arch-Max/) (Cortex-M4F)


 Nordic:
 * [nRF51822-mKIT](https://developer.mbed.org/platforms/Nordic-nRF51822/) (Cortex-M0)
 * [Arch BLE](https://developer.mbed.org/platforms/Seeed-Arch-BLE/) (Cortex-M0)

 Renesas:
 * [RZ-A1H](http://developer.mbed.org/platforms/Renesas-GR-PEACH/) (Cortex-A9)


 Supported Toolchains and IDEs
 -----------------------------
 * GCC ARM: [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded/4.7/4.7-2012-q4-major)
 * ARMCC (standard library and MicroLib): [uVision](http://www.keil.com/uvision/)
 * IAR: [IAR Embedded Workbench](http://www.iar.com/en/Products/IAR-Embedded-Workbench/ARM/)
 * GCC code_red: [Red Suite](http://www.code-red-tech.com/)
 * GCC CodeSourcery: [Sourcery CodeBench](http://www.mentor.com/embedded-software/codesourcery)
 * GCC ARM: [Em::Blocks](http://www.emblocks.org/web/)
 * GCC ARM: [CooCox CoIDE](http://www.coocox.org/)

 API Documentation
 -----------------
 * [RTOS API](http://developer.mbed.org/handbook/RTOS)
 * [TCP/IP Socket API](http://developer.mbed.org/handbook/Socket) (Transports: Ethernet, WiFi, 3G)
 * [USB Device API](http://developer.mbed.org/handbook/USBDevice)
 * [USB Host API](http://developer.mbed.org/handbook/USBHost)
 * [DSP API](http://developer.mbed.org/users/mbed_official/code/mbed-dsp/docs/tip/)
 * Flash File Systems: [SD](http://developer.mbed.org/handbook/SDFileSystem), [USB MSD](http://developer.mbed.org/handbook/USBHostMSD), [semihosted](http://developer.mbed.org/handbook/LocalFileSystem)
 * [Peripheral Drivers API](http://developer.mbed.org/handbook/Homepage)

 Community
 ---------
 For discussing the development of the mbed SDK itself (Addition/support of microcontrollers/toolchains, build and test system, Hardware Abstraction Layer API, etc) please join our [mbed-devel mailing list](https://groups.google.com/forum/?fromgroups#!forum/mbed-devel).

 For every topic regarding the use of the mbed SDK, rather than its development, please post on the [mbed.org forum](http://mbed.org/forum/), or the [mbed.org Q&A](http://mbed.org/questions/).

 For reporting issues in the mbed libraries please open a ticket on the issue tracker of the relevant [mbed official library](http://mbed.org/users/mbed_official/code/).
--- a/tmk_core/tool/mbed/mbed-sdk/docs/BUILDING.md
+++ b/tmk_core/tool/mbed/mbed-sdk/docs/BUILDING.md
@@ -0,0 +1,601 @@
 # Mbed SDK build script environment
 ## Introduction
 Mbed test framework allows users to test their mbed devices’ applications, build mbed SDK library, re-run tests, run mbed SDK regression, add new tests and get all this results automatically. Everything is done on your machine so you have a full control over compilation, and tests you run.

 It's is using Python 2.7 programming language to drive all tests so make sure Python 2.7 is installed on your system and included in your system PATH. To compile mbed SDK and tests you will need one or more supported compilers installed on your system.

 To follow this short introduction you should already:
 * Know what mbed SDK is in general.
 * Know how to install Python 2.7, ARM target cross compilers.
 * You have C/C++ programming experience and at least willingness to learn a bit about Python. 

 ## Test automation
 Currently our simple test framework allows users to run tests on their machines (hosts) in a fully automated manner. All you need to do is to prepare two configuration files.

 ## Test automation limitations
 Note that for tests which require connected external peripherals, for example Ethernet, SD flash cards, external EEPROM tests, loops etc. you need to:

 * Modify test source code to match components' pin names to actual mbed board pins where peripheral is connected or
 * Wire your board the same way test defines it.

 ## Prerequisites
 mbed test suite and build scripts are Python 2.7 applications and require Python 2.7 runtime environment and [setuptools](https://pythonhosted.org/an_example_pypi_project/setuptools.html) to install dependencies.

 What we need:
 * Installed [Python 2.7](https://www.python.org/download/releases/2.7) programming language.
 * Installed [setuptools](https://pythonhosted.org/an_example_pypi_project/setuptools.html#installing-setuptools-and-easy-install) 
 * Optionally you can install [pip](https://pip.pypa.io/en/latest/installing.html) which is the PyPA recommended tool for installing Python packages from command line.

 mbed SDK in its repo root directory specifies ```setup.py``` file which holds information about all packages which are dependencies for it. Bear in mind only few simple steps are required to install all dependencies.

 First, clone mbed SDK repo and go to mbed SDk repo's directory:
 ```
 $ git clone https://github.com/mbedmicro/mbed.git
 $ cd mbed
 ```

 Second, invoke ```setup.py``` so ```setuptools``` can install mbed SDK's dependencies (external Python modules required by mbed SDK):
 ```
 $ python setup.py install
 ```
 or 
 ```
 $ sudo python setup.py install
 ```
 when your system requires administrator rights to install new Python packages.

 ## Prerequisites (manual Python package dependency installation)
 **Please only read this chapter if you had problems installing mbed SDK dependencies to Python packages**.

 Below you can find the list of mbed SDK dependencies to Python modules with instructions how to install them manually.

 You can skip this part if you've already install [Python 2.7](https://www.python.org/download/releases/2.7) and [setuptools](https://pythonhosted.org/an_example_pypi_project/setuptools.html) and successfully [installed all dependencies](#prerequisites).

 * Please make sure you've installed [pip](https://pip.pypa.io/en/latest/installing.html) or [easy_install](https://pythonhosted.org/setuptools/easy_install.html#installing-easy-install) 
 Note: Easy Install is a python module (easy_install) bundled with [setuptools](https://pythonhosted.org/an_example_pypi_project/setuptools.html#installing-setuptools-and-easy-install) that lets you automatically download, build, install, and manage Python packages.

 * Installed [pySerial](https://pypi.python.org/pypi/pyserial) module for Python 2.7.
 pySerial can be installed from PyPI, either manually downloading the files and installing as described below or using:
 ```
 $ pip install pyserial
 ```
 or:
 ```
 easy_install -U pyserial
 ```
 * Installed [prettytable](https://code.google.com/p/prettytable/wiki/Installation) module for Python 2.7.
 prettytable can be installed from PyPI, either manually downloading the files and installing as described below or using:
 ```
 $ pip install prettytable
 ```
 * Installed [IntelHex](https://pypi.python.org/pypi/IntelHex) module.
 IntelHex may be downloaded from https://launchpad.net/intelhex/+download or http://www.bialix.com/intelhex/.
 Assuming Python is properly installed on your platform, installation should just require running the following command from the root directory of the archive:
 ```
 sudo python setup.py install
 ```
 This will install the intelhex package into your system’s site-packages directory. After that is done, any other Python scripts or modules should be able to import the package using:
 ```
 $ python
 Python 2.7.8 (default, Jun 30 2014, 16:03:49) [MSC v.1500 32 bit (Intel)] on win32
 Type "help", "copyright", "credits" or "license" for more information.
 >>> from intelhex import IntelHex
 >>>
 ```
 * You can check if you have correctly installed the above modules (or you already have them) by starting Python and importing both modules.
 ```
 $ python
 Python 2.7.8 (default, Jun 30 2014, 16:03:49) [MSC v.1500 32 bit (Intel)] on win32
 Type "help", "copyright", "credits" or "license" for more information.
 >>> import serial
 >>> import prettytable
 >>> from intelhex import IntelHex
 >>>
 ```
 * Installed Git open source distributed version control system.
 * Installed at least one of the supported by Mbed SDK workspace tools compilers: 

 Compiler | Mbed SDK Abbreviation | Example Version
 -----------------------|-----------------------|-----------
 Keil ARM Compiler | ARM, uARM | ARM C/C++ Compiler, 5.03 [Build 117]
 GCC ARM | GCC_ARM | gcc version 4.8.3 20131129 (release)
 GCC CodeSourcery | GCC_CS | gcc version 4.8.1 (Sourcery CodeBench Lite 2013.11-24)
 GCC CodeRed | GCC_CR | gcc version 4.6.2 20121016 (release)
 IAR Embedded Workbench | IAR | IAR ANSI C/C++ Compiler V6.70.1.5641/W32 for ARM

 * Mbed board. You can find list of supported platforms [here](https://mbed.org/platforms/).

 ### Getting Mbed SDK sources with test suite
 So you have already installed Python (with required modules) together with at least one supported compiler you will use with your mbed board. Great!

 Now let's go further and try to get Mbed SDK with test suite together. So let's clone latest Mbed SDK source code and configure path to our compiler(s) in next few steps.

 * Open console and run command below to clone Mbed SDK repository hosted on [Github](https://github.com/mbedmicro/mbed).
 ```
 $ git clone https://github.com/mbedmicro/mbed.git
 Cloning into 'mbed'...
 remote: Counting objects: 37221, done.
 remote: Compressing objects: 100% (3/3), done.
 remote: Total 37221 (delta 0), reused 0 (delta 0), pack-reused 37218
 Receiving objects: 100% (37221/37221), 20.38 MiB | 511.00 KiB/s, done.
 Resolving deltas: 100% (24455/24455), done.
 Checking connectivity... done.
 Checking out files: 100% (3994/3994), done.
 ```
 * Now you can go to mbed directory you've just cloned and you can see root directory structure of our Mbed SDK library sources. Just type following commands:
 ```
 $ cd mbed
 $ ls
 LICENSE MANIFEST.in README.md libraries setup.py travis workspace_tools
 ```
 Directory structure we are interested in:
 ```
 mbed/workspace_tools/ - test suite scripts, build scripts etc.
 mbed/library/tests/ - mbed SDK tests,
 mbed/library/tests/mbed/ - tests for mbed SDK and peripherals tests,
 mbed/library/tests/net/echo/ - tests for Ethernet interface,
 mbed/library/tests/rtos/mbed/ - tests for RTOS. 
 ```

 ### Workspace tools
 Workspace tools are set of Python scripts used off-line by Mbed SDK team to:
 * Compile and build mbed SDK,
 * Compile and build libraries included in mbed SDK repo like e.g. ETH (Ethernet), USB, RTOS or CMSIS,
 * Compile, build and run mbed SDK tests,
 * Run test regression locally and in CI server,
 * Get library, target, test configuration (paths, parameters, names etc.).

 ### Configure workspace tools to work with your compilers
 Before we can run our first test we need to configure our test environment a little!
 Now we need to tell workspace tools where our compilers are.

 * Please to go ```mbed/workspace_tools/``` directory and create empty file called ```private_settings.py```.
 ```
 $ touch private_settings.py
 ```
 * Populate this file the Python code below: 
 ```python
 from os.path import join
 
 # ARMCC
 ARM_PATH = "C:/Work/toolchains/ARMCompiler_5.03_117_Windows"
 ARM_BIN = join(ARM_PATH, "bin")
 ARM_INC = join(ARM_PATH, "include")
 ARM_LIB = join(ARM_PATH, "lib")
 
 ARM_CPPLIB = join(ARM_LIB, "cpplib")
 MY_ARM_CLIB = join(ARM_PATH, "lib", "microlib")
 
 # GCC ARM
 GCC_ARM_PATH = "C:/Work/toolchains/gcc_arm_4_8/4_8_2013q4/bin"
 
 # GCC CodeSourcery
 GCC_CS_PATH = "C:/Work/toolchains/Sourcery_CodeBench_Lite_for_ARM_EABI/bin"
 
 # GCC CodeRed
 GCC_CR_PATH = "C:/Work/toolchains/LPCXpresso_6.1.4_194/lpcxpresso/tools/bin"
 
 # IAR
 IAR_PATH = "C:/Work/toolchains/iar_6_5/arm"
 
 SERVER_ADDRESS = "127.0.0.1"
 LOCALHOST = "127.0.0.1"
 
 # This is moved to separate JSON configuration file used by singletest.py
 MUTs = {
 }
 ```

 Note: You need to provide the absolute path to your compiler(s) installed on your host machine. Replace corresponding variable values with paths to compilers installed in your system:
 * ```ARM_PATH``` for armcc compiler.
 * ```GCC_ARM_PATH``` for GCC ARM compiler.
 * ```GCC_CS_PATH``` for GCC CodeSourcery compiler.
 * ```GCC_CR_PATH``` for GCC CodeRed compiler.
 * ```IAR_PATH``` for IAR compiler. 

 If for example you do not use ```IAR``` compiler you do not have to modify anything. Workspace tools will use ```IAR_PATH`` variable only if you explicit ask for it from command line. So do not worry and replace only paths for your installed compilers.

 Note: Because this is a Python script and ```ARM_PATH```, ```GCC_ARM_PATH```, ```GCC_CS_PATH```, ```GCC_CR_PATH```, ```IAR_PATH``` are Python string variables please use double backlash or single slash as path's directories delimiter to avoid incorrect path format. For example:
 ```python
 ARM_PATH = "C:/Work/toolchains/ARMCompiler_5.03_117_Windows"
 GCC_ARM_PATH = "C:/Work/toolchains/gcc_arm_4_8/4_8_2013q4/bin"
 GCC_CS_PATH = "C:/Work/toolchains/Sourcery_CodeBench_Lite_for_ARM_EABI/bin"
 GCC_CR_PATH = "C:/Work/toolchains/LPCXpresso_6.1.4_194/lpcxpresso/tools/bin"
 IAR_PATH = "C:/Work/toolchains/iar_6_5/arm"
 ```

 Note: Settings in ```private_settings.py``` will overwrite variables with default values in ```mbed/workspace_tools/settings.py``` file.

 ## Build Mbed SDK library from sources
 Let's build mbed SDK library off-line from sources using your compiler. We've already cloned mbed SDK sources, we've also installed compilers and added their paths to ```private_settings.py```.
 We now should be ready to use workspace tools script ```build.py``` to compile and build mbed SDK from sources.

 We are still using console. You should be already in ```mbed/workspace_tools/``` directory if not go to ```mbed/workspace_tools/``` and type below command:
 ```
 $ python build.py -m LPC1768 -t ARM
 ```
 or if you want to take advantage from multi-threaded compilation please use option ```-j X``` where ```X``` is number of cores you want to use to compile mbed SDK. See below:
 ```
 $ python build.py -m LPC1768 -t ARM -j 4
 Building library CMSIS (LPC1768, ARM)
 Copy: core_ca9.h
 Copy: core_caFunc.h
 ...
 Compile: us_ticker_api.c
 Compile: wait_api.c
 Library: mbed.ar
 Creating archive 'C:\temp\x\mbed\build\mbed\TARGET_LPC1768\TOOLCHAIN_ARM_STD\mbed.ar'
 Copy: board.o
 Copy: retarget.o

 Completed in: (42.58)s

 Build successes:
 * ARM::LPC1768
 ```
 Above command will build mbed SDK for [LPC1768](http://developer.mbed.org/platforms/mbed-LPC1768/) platform using ARM compiler.

 Let's have a look at directory structure under ```mbed/build/```. We can see for ```LPC1768``` new directory ```TARGET_LPC1768``` was created. This directory contains all build primitives.
 Directory ```mbed/TARGET_LPC1768/TOOLCHAIN_ARM_STD/``` conteins mbed SDK library ```mbed.ar```. This directory structure also stores all needed headers which you should use with ```mbed.ar``` when building your own software.
 ```
 $ tree ./mbed/build/
 Folder PATH listing
 Volume serial number is 006C006F 6243:3EA9
 ./MBED/BUILD
 +---mbed
 +---.temp
 ¦ +---TARGET_LPC1768
 ¦ +---TOOLCHAIN_ARM_STD
 ¦ +---TARGET_NXP
 ¦ +---TARGET_LPC176X
 ¦ +---TOOLCHAIN_ARM_STD
 +---TARGET_LPC1768
 +---TARGET_NXP
 ¦ +---TARGET_LPC176X
 ¦ +---TARGET_MBED_LPC1768
 +---TOOLCHAIN_ARM_STD
 ```

 Note: Why ```LCP1768```? For this example we are using ```LPC1768``` because this platform supports all compilers so you are sure you only need to specify proper compiler.

 If you are not using ARM Compiler replace ```ARM``` with your compiler nickname: ```GCC_ARM```, ```GCC_CS```, ```GCC_CR``` or ```IAR```. For example if you are using IAR type command:
 ```
 $ python build.py -m LPC1768 -t IAR
 ```

 Note: Workspace tools track changes in source code. So if for example mbed SDK or test source code changes ```build.py``` script will recompile project with all dependencies. If there are no changes in code consecutive mbed SDK re-builds using build.py will not rebuild project if this is not necessary. Try to run last command once again, we can see script ```build.py``` will not recompile project (there are no changes): 
 ```
 $ python build.py -m LPC1768 -t ARM
 Building library CMSIS (LPC1768, ARM)
 Building library MBED (LPC1768, ARM)

 Completed in: (0.15)s

 Build successes:
 * ARM::LPC1768
 ```

 ### build.py script

 Build script located in mbed/workspace_tools/ is our core script solution to drive compilation, linking and building process for:

 * mbed SDK (with libs like Ethernet, RTOS, USB, USB host).
 * Tests which also can be linked with libraries like RTOS or Ethernet.

 Note: Test suite also uses the same build script, inheriting the same properties like auto dependency tracking and project rebuild in case of source code changes.

 Build.py script is a powerful tool to build mbed SDK for all available platforms using all supported by mbed cross-compilers. Script is using our workspace tools build API to create desired platform-compiler builds. Use script option ```--h``` (help) to check all script parameters.
 ```
 $ python build.py --help
 ```

 * The command line parameter ```-m``` specifies the MCUs/platforms for which you want to build the mbed SDK. More than one MCU(s)/platform(s) may be specified with this parameter using comma as delimiter.
 Example for one platform build:
 ```
 $ python build.py -m LPC1768 -t ARM
 ```
 or for many platforms:
 ```
 $ python build.py -m LPC1768,NUCLEO_L152RE -t ARM
 ```

 * Parameter ```-t``` defined which toolchain should be used for mbed SDK build. You can build Mbed SDK for multiple toolchains using one command. 
 Below example (note there is no space after commas) will compile mbed SDK for Freescale Freedom KL25Z platform using ARM and GCC_ARM compilers:
 ```
 $ python build.py -m KL25Z -t ARM,GCC_ARM
 ```

 * You can combine this technique to compile multiple targets with multiple compilers.
 Below example will compile mbed SDK for Freescale's KL25Z and KL46Z platforms using ARM and GCC_ARM compilers:
 ```
 $ python build.py -m KL25Z,KL46Z -t ARM,GCC_ARM
 ```

 * Building libraries included in mbed SDK's source code. Parameters ```-r```, ```-e```, ```-u```, ```-U```, ```-d```, ```-b``` will add ```RTOS```, ```Ethernet```, ```USB```, ```USB Host```, ```DSP```, ```U-Blox``` libraries respectively. 
 Below example will build Mbed SDK library for for NXP LPC1768 platform together with RTOS (```-r``` switch) and Ethernet (```-e``` switch) libraries.
 ```
 $ python build.py -m LPC1768 -t ARM -r -e
 Building library CMSIS (LPC1768, ARM)
 Building library MBED (LPC1768, ARM)
 Building library RTX (LPC1768, ARM)
 Building library RTOS (LPC1768, ARM)
 Building library ETH (LPC1768, ARM)

 Completed in: (0.48)s

 Build successes:
 * ARM::LPC1768
 ```

 * If you’re unsure which platforms and toolchains are supported please use switch ```-S``` to print simple matrix of platform to compiler dependencies.
 ```
 $ python python build.py -S
 +-------------------------+-----------+-----------+-----------+-----------+-----------+-----------+------------+---------------+
 | Platform | ARM | uARM | GCC_ARM | IAR | GCC_CR | GCC_CS | GCC_CW_EWL | GCC_CW_NEWLIB |
 +-------------------------+-----------+-----------+-----------+-----------+-----------+-----------+------------+---------------+
 | APPNEARME_MICRONFCBOARD | Supported | Default | Supported | - | - | - | - | - |
 | ARCH_BLE | Default | - | Supported | Supported | - | - | - | - |
 | ARCH_GPRS | Supported | Default | Supported | Supported | Supported | - | - | - |
 ...
 | UBLOX_C029 | Supported | Default | Supported | Supported | - | - | - | - |
 | WALLBOT_BLE | Default | - | Supported | Supported | - | - | - | - |
 | XADOW_M0 | Supported | Default | Supported | Supported | Supported | - | - | - |
 +-------------------------+-----------+-----------+-----------+-----------+-----------+-----------+------------+---------------+
 *Default - default on-line compiler
 *Supported - supported off-line compiler

 Total platforms: 90
 Total permutations: 297
 ```

 Above list can be overwhelming so please do not hesitate to use switch ```-f``` to filter ```Platform``` column.
 ```
 $ python build.py -S -f ^K
 +--------------+-----------+---------+-----------+-----------+--------+--------+------------+---------------+
 | Platform | ARM | uARM | GCC_ARM | IAR | GCC_CR | GCC_CS | GCC_CW_EWL | GCC_CW_NEWLIB |
 +--------------+-----------+---------+-----------+-----------+--------+--------+------------+---------------+
 | K20D50M | Default | - | Supported | Supported | - | - | - | - |
 | K22F | Default | - | Supported | Supported | - | - | - | - |
 | K64F | Default | - | Supported | Supported | - | - | - | - |
 | KL05Z | Supported | Default | Supported | Supported | - | - | - | - |
 | KL25Z | Default | - | Supported | Supported | - | - | Supported | Supported |
 | KL43Z | Default | - | Supported | - | - | - | - | - |
 | KL46Z | Default | - | Supported | Supported | - | - | - | - |
 | NRF51_DK | Default | - | Supported | Supported | - | - | - | - |
 | NRF51_DK_OTA | Default | - | Supported | - | - | - | - | - |
 +--------------+-----------+---------+-----------+-----------+--------+--------+------------+---------------+
 *Default - default on-line compiler
 *Supported - supported off-line compiler

 Total platforms: 9
 Total permutations: 28
 ```
 or just give platform name:
 ```
 $ python build.py -S -f LPC1768
 +----------+---------+-----------+-----------+-----------+-----------+-----------+------------+---------------+
 | Platform | ARM | uARM | GCC_ARM | IAR | GCC_CR | GCC_CS | GCC_CW_EWL | GCC_CW_NEWLIB |
 +----------+---------+-----------+-----------+-----------+-----------+-----------+------------+---------------+
 | LPC1768 | Default | Supported | Supported | Supported | Supported | Supported | - | - |
 +----------+---------+-----------+-----------+-----------+-----------+-----------+------------+---------------+
 *Default - default on-line compiler
 *Supported - supported off-line compiler

 Total platforms: 1
 Total permutations: 6
 ```

 * You can be more verbose ```-v``` especially if you want to see each compilation / linking command build.py is executing:
 ```
 $ python build.py -t GCC_ARM -m LPC1768 -j 8 -v
 Building library CMSIS (LPC1768, GCC_ARM)
 Copy: LPC1768.ld
 Compile: startup_LPC17xx.s
 [DEBUG] Command: C:/Work/toolchains/gcc_arm_4_8/4_8_2013q4/bin\arm-none-eabi-gcc 
 -x assembler-with-cpp -c -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers 
 -fmessage-length=0 -fno-exceptions -fno-builtin -ffunction-sections -fdata-sections -MMD 
 -fno-delete-null-pointer-checks -fomit-frame-pointer -mcpu=cortex-m3 -mthumb -O2 
 -DTARGET_LPC1768 -DTARGET_M3 -DTARGET_CORTEX_M -DTARGET_NXP -DTARGET_LPC176X 
 -DTARGET_MBED_LPC1768 -DTOOLCHAIN_GCC_ARM -DTOOLCHAIN_GCC -D__CORTEX_M3 -DARM_MATH_CM3 
 -DMBED_BUILD_TIMESTAMP=1424903604.77 -D__MBED__=1 -IC:\Work\mbed\libraries\mbed\targets\cmsis 
 -IC:\Work\mbed\libraries\mbed\targets\cmsis\TARGET_NXP 
 -IC:\Work\mbed\libraries\mbed\targets\cmsis\TARGET_NXP\TARGET_LPC176X -IC:\Work\mbed\libraries\mbed\targets\cmsis\TARGET_NXP\TARGET_LPC176X\TOOLCHAIN_GCC_ARM 
 -o C:\Work\mbed\build\mbed\.temp\TARGET_LPC1768\TOOLCHAIN_GCC_ARM\TARGET_NXP\TARGET_LPC176X\TOOLCHAIN_GCC_ARM\startup_LPC17xx.o 
 C:\Work\mbed\libraries\mbed\targets\cmsis\TARGET_NXP\TARGET_LPC176X\TOOLCHAIN_GCC_ARM\startup_LPC17xx.s
 [DEBUG] Return: 0
 ...
 ```

 ## CppUCheck analysis
 [Cppcheck](http://cppcheck.sourceforge.net/) is a static analysis tool for C/C++ code. Unlike C/C++ compilers and many other analysis tools it does not detect syntax errors in the code. Cppcheck primarily detects the types of bugs that the compilers normally do not detect. The goal is to detect only real errors in the code (i.e. have zero false positives).

 Prerequisites:
 * Please install ```CppCheck``` on your system before you want to use it with build scripts.
 * You should also add Cppcheck to your system path.

 ```build.py``` script supports switching between compilation and building and just static code analysis testing. You can use switch ```--cppcheck``` to perform CppCheck static code analysis. 

 * When you are using --cppcheck switch all macros, toolchain dependencies etc. are preserved so you are sure you are checking exactly the same code you would compile for your application.

 * Cppcheck analysis can take up to few minutes on slower machines.

 * Usually you will use switches ```-t``` and ```-m``` to define toolchain and MCU (platform) respectively. You should do the same in case of CppCheck analysis. Please note that build script can also compile and build RTOS, Ethernet library etc. If you want to check those just use corresponding build script switches (e.g. ```-r```, ```-e```, ...).

 Example:
 ```
 $ python build.py -t uARM -m NUCLEO_F334R8 --cppcheck
 ```

 # make.py script
 ```make.pt``` is a ```mbed/workspace_tools/``` script used to build tests (we call them sometimes 'programs') one by one manually. Script allows you to flash board with test and execute it. This is deprecated functionality and will not be described here. Instead please use ```singletest.py``` file to build mbed SDK, tests and run automation for test cases included in ```mbedmicro/mbed```.
 Note: ```make.py``` script depends on existing already built mked SDK and library sources so you need to pre-build mbed SDK and for example RTOS library to link 'program' (test) with mebd SDK and RTOS library. To pre-build mbed SDK please use ```build.py``` script.

 Just for sake of example please see few ways to use ```make.py``` together with Freedom K64F board.

 * We need to build mbed SDK (in directory ```mbed/build/```:
 ```
 $ python build.py -t GCC_ARM -m K64F -j 8
 Building library CMSIS (K64F, GCC_ARM)
 Building library MBED (K64F, GCC_ARM)

 Completed in: (0.59)s

 Build successes:
 * GCC_ARM::K64F
 ```
 * We can print all 'programs' (test cases) ```make.py``` can build for us:
 ```
 $ python make.py
 .
 [ 0] MBED_A1: Basic
 [ 1] MBED_A2: Semihost file system
 [ 2] MBED_A3: C++ STL
 [ 3] MBED_A4: I2C TMP102
 .
 ```
 For example 'program' under index ```2``` is ```MBED_A3``` test case we can build and flash onto K64F board.
 * Building test with ```make.py``` by specifying test case name with ```-n``` option:
 ```
 $ python make.py -t GCC_ARM -m K64F -n MBED_A3
 Building project STL (K64F, GCC_ARM)
 Compile: main.cpp
 [Warning] main.cpp@76: In function 'int main()': deprecated conversion from string constant to 'char*' [-Wwrite-strings]
 .
 .
 .
 [Warning] main.cpp@76: In function 'int main()': deprecated conversion from string constant to 'char*' [-Wwrite-strings]
 Compile: test_env.cpp
 Link: stl
 Elf2Bin: stl
 Image: C:\Work\mbed\build\test\K64F\GCC_ARM\MBED_A3\stl.bin
 ```
 Because we previously have built mbed SDK we are now able to drive test case compilation and linking with mbed SDK and produce ```MBED_A3``` test case binary in build directory:
 ```
 C:\Work\mbed\build\test\K64F\GCC_ARM\MBED_A3\stl.bin
 ```

 For more help type ```$ python make.py --help``` in your command line.

 # project.py script
 ```project.py``` script is used to export test cases ('programs') from test case portfolio to off-line IDE. This is a easy way to export test project to IDEs such as:
 * codesourcery.
 * coide.
 * ds5_5.
 * emblocks.
 * gcc_arm.
 * iar.
 * kds.
 * lpcxpresso.
 * uvision.

 You can export project using command line. All you need to do is to specify mbed platform name (option ```-m```), your IDE (option ```-i```) and project name you want to export (option ```-n``` or (option ```-p```).

 In below example we export our project so we can work on it using GCC ARM cross-compiler. Building mechanism used to drive exported build will be ```Make```.
 ```
 $ python project.py -m K64F -n MBED_A3 -i gcc_arm
 Copy: test_env.h
 Copy: AnalogIn.h
 Copy: AnalogOut.h
 .
 .
 .
 Copy: K64FN1M0xxx12.ld
 Copy: main.cpp

 Successful exports:
 * K64F::gcc_arm C:\Work\mbed\build\export\MBED_A3_gcc_arm_K64F.zip
 ```
 You can see exporter placed compressed project export in ```zip``` file in ```mbed/build/export/``` directory.

 Example export file ```MBED_A3_gcc_arm_K64F.zip``` structure:
 ```
 MBED_A3
 ├───env
 └───mbed
 ├───api
 ├───common
 ├───hal
 └───targets
 ├───cmsis
 │ └───TARGET_Freescale
 │ └───TARGET_MCU_K64F
 │ └───TOOLCHAIN_GCC_ARM
 └───hal
 └───TARGET_Freescale
 └───TARGET_KPSDK_MCUS
 ├───TARGET_KPSDK_CODE
 │ ├───common
 │ │ └───phyksz8081
 │ ├───drivers
 │ │ ├───clock
 │ │ ├───enet
 │ │ │ └───src
 │ │ ├───interrupt
 │ │ └───pit
 │ │ ├───common
 │ │ └───src
 │ ├───hal
 │ │ ├───adc
 │ │ ├───can
 │ │ ├───dac
 │ │ ├───dmamux
 │ │ ├───dspi
 │ │ ├───edma
 │ │ ├───enet
 │ │ ├───flextimer
 │ │ ├───gpio
 │ │ ├───i2c
 │ │ ├───llwu
 │ │ ├───lptmr
 │ │ ├───lpuart
 │ │ ├───mcg
 │ │ ├───mpu
 │ │ ├───osc
 │ │ ├───pdb
 │ │ ├───pit
 │ │ ├───pmc
 │ │ ├───port
 │ │ ├───rcm
 │ │ ├───rtc
 │ │ ├───sai
 │ │ ├───sdhc
 │ │ ├───sim
 │ │ ├───smc
 │ │ ├───uart
 │ │ └───wdog
 │ └───utilities
 │ └───src
 └───TARGET_MCU_K64F
 ├───device
 │ ├───device
 │ │ └───MK64F12
 │ └───MK64F12
 ├───MK64F12
 └───TARGET_FRDM
 ```

 After unpacking exporter ```zip``` file we can go to directory and see files inside MBED_A3 directory:
 ```
 $ ls
 GettingStarted.htm Makefile env main.cpp mbed
 ```
 Exporter generated for us ```Makefile``` so now we can build our software:
 ```
 $ make -j 8
 .
 .
 .
 text data bss dec hex filename
 29336 184 336 29856 74a0 MBED_A3.elf
 ```

 We can see root directory of exporter project is now populated with binary files:
 * MBED_A3.bin.
 * MBED_A3.elf .
 * MBED_A3.hex.
 You have also map file ```MBED_A3.map``` for your disposal.
 ```
 $ ls
 GettingStarted.htm MBED_A3.bin MBED_A3.elf MBED_A3.hex MBED_A3.map Makefile env main.cpp main.d main.o mbed
 ```

--- a/tmk_core/tool/mbed/mbed-sdk/docs/COMMITTERS.md
+++ b/tmk_core/tool/mbed/mbed-sdk/docs/COMMITTERS.md
@@ -0,0 +1,269 @@
 # Committing changes to mbedmicro/mbed
 * Our current branching model is very simple. We are using ```master``` branch to merge all pull requests.
 * Based on stable ```SHA``` version of ```master``` branch we decide to release and att he same time ```tag``` our build release.
 * Our current release versioning follows simple integer version: ```94```, ```95```, ```96``` etc.

 # Committer Guide

 ## How to decide what release(s) should be patched
 This section provides a guide to help a committer decide the specific base branch that a change set should be merged into.

 Currently our default branch is ```master``` branch. All pull requests should be created against ```master``` branch. 
 mbed SDK is released currently on master branch under certain tag name (see [Git tagging basics]( http://git-scm.com/book/en/v2/Git-Basics-Tagging)). You can see mbed SDK tags and switch between them to for example go back to previous mbed SDK release. 
 ```
 $ git tag
 ```

 Please note: mebd SDK ```master``` branch's ```HEAD``` is our latest code and may not be as stable as you expect. We are putting our best effort to run regression testing (in-house) against pull requests and latest code.
 Each commit to ```master``` will trigger [GitHub's Travis Continuous Integration](https://travis-ci.org/mbedmicro/mbed/builds).

 ### Pull request
 Please send pull requests with changes which are:
 * Complete (your code will compile and perform as expected).
 * Tested on hardware.
 * You can use included mbed SDK test suite to perform testing. See TESTING.md.
 * If your change, feature do not have a test case included please add one (or more) to cover new functionality.
 * If you can't test your functionality describe why.
 * Documented source code:
 * New, modified functions have descriptive comments.
 * You follow coding rules and styles provided by mbed SDK project.
 * Documented pull request description:
 * Description of changes is added - explain your change / enhancement.
 * References to existing issues, other pull requests or forum discussions are included.
 * Test results are added.

 After you send us your pull request our Gate Keeper will change the state of pull request to:
 • ``` enhancement``` or ```bug``` when pull request creates new improvement or fixed issue.
 Than we will set for you labels:
 • ```review``` to let you know your pull request is under review and you can expect review related comments from us.
 • ```in progress``` when you pull request requires some additional change which will for now block this pull request from merging.
 At the end we will remove ```review``` label and merge your change if everything goes well.

 ## C++ coding rules & coding guidelines
 ### Rules
 * The mbed SDK code follows K&R style (Reference: [K&R style](http://en.wikipedia.org/wiki/Indent_style#K.26R_style)) with at least 2 exceptions which can be found in the list below the code snippet:

 ```c++
 static const PinMap PinMap_ADC[] = {
 {PTC2, ADC0_SE4b, 0},
 {NC , NC , 0}
 };

 uint32_t adc_function(analogin_t *obj, uint32_t options)
 {
 uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;
 switch (options) {
 case 1:
 timeout = 6;
 break;
 default:
 timeout = 10;
 break;
 }

 while (!adc_hal_is_conversion_completed(instance, 0)) {
 if (timeout == 0) {
 break;
 } else {
 timeout--;
 }
 }

 if (obj->adc == ADC_CHANNEL0) {
 adc_measure_channel(instance);
 adc_stop_channel(instance);
 } else {
 error("channel not available");
 }

 #if DEBUG
 for (uint32_t i = 0; i < 10; i++) {
 printf("Loop : %d", i);
 }
 #endif
 return adc_hal_get_conversion_value(instance, 0);
 }
 ```
 * Indentation - 4 spaces. Please do not use tabs!
 * Braces - K&R, except for functions where the opening brace is on the new line.
 * 1 TBS - use braces for statements ```if```, ```else```, ```while```, ```for``` (exception from K&R) Reference: [1TBS](http://en.wikipedia.org/wiki/Indent_style#Variant:_1TBS)).
 * One line per statement.
 * Preprocessor macro starts at the beginning of a new line, the code inside is indented accordingly the code above it.
 * Cases within switch are indented (exception from K&R).
 * Space after statements if, while, for, switch, same applies to binary and ternary operators.
 * Each line has preferably at most 120 characters.
 * For pointers, ```*``` is adjacent to a name (analogin_t *obj).
 * Don't leave trailing spaces at the end of lines.
 * Empty lines should have no trailing spaces.
 * Unix line endings are default option for files.
 * Use capital letters for macros.
 * A file should have an empty line at the end.
 and:
 * We are not using C++11 yet so do not write code compliant to this standard.
 * We are not using libraries like ```BOOST``` so please so not include any ```BOOST``` headers to your code.
 * C++ & templates: please take under consideration templates are not fully supported by cross-compilers. You may have difficulties compiling template code few cross-compilers so make sure your template code compilers for more than one compiler.

 ### Naming conventions
 Classes:
 * Begins with a capital letter, and each word in it begins also with a capital letter (```AnalogIn```, ```BusInOut```).
 * Methods contain small letters, distinct words separated by underscore.
 * Private members starts with an underscore.

 User defined types (typedef):
 * Structures - suffix ```_t``` - to denote it is user defined type
 * Enumeration - the type name and values name - same naming convention as classes (e.g ```MyNewEnum```)

 Functions:
 * Contain lower case letters (as methods within classes)
 * Distinct words separated by underscore (```wait_ms```, ```read_u16```)
 * Please make sure that in your module all functions have unique prefix so when your module is compiled with other modules function names (and e.g. extern global variable names) are not in naming conflict.

 Example code look&feel:
 ```c++
 #define ADC_INSTANCE_SHIFT 8

 class AnalogIn {
 public:
 /** Create an AnalogIn, connected to the specified pin
 *
 * @param pin AnalogIn pin to connect to
 * @param name (optional) A string to identify the object
 */
 AnalogIn(PinName pin) {
 analogin_init(&_adc, pin);
 }

 /** Read the input voltage, represented as a float in the range [0.0, 1.0]
 *
 * @returns
 * A floating-point value representing the current input voltage, measured as a percentage
 */
 uint32_t read() {
 return analogin_read(&_adc, operation);
 }

 protected:
 analogin_t _adc;
 };

 typedef enum {
 ADC0_SE0 = (0 << ADC_INSTANCE_SHIFT) | 0,
 } ADCName;

 struct analogin_s {
 ADCName adc;
 };

 typedef struct analogin_s analogin_t;
 ```
 ### Doxygen documentation
 All functions / methods should contain a documentation using doxygen javadoc in a header file. More information regarding writing API Documentation, follow [this](https://mbed.org/handbook/API-Documentation) link.

 Example of well documentet code:
 ```c++
 #ifndef ADC_H
 #define ADC_H

 #ifdef __cplusplus
 extern "C" {
 #endif

 /** ADC Measurement method
 *
 * @param obj Pointer to the analogin object.
 * @param options Options to be enabled by ADC peripheral.
 *
 * @returns
 * Measurement value on defined ADC channel.
 */
 uint32_t adc_function(analogin_t *obj, uint32_t options)

 #ifdef __cplusplus
 }
 #endif

 #endif
 ```
 ### C/C++ Source code indenter
 In Mbed project you can use AStyle (Reference: [Artistic Style](http://astyle.sourceforge.net/)) source code indenter to help you auto format your source code. It will for sure not correct all your coding styles but for sure will eliminate most of them. You can download AStyle from this location.

 Official Mbed SDK styles include below AStyle styles (defined by command line switched):
 ```
 --style=kr --indent=spaces=4 --indent-switches
 ```
 To format your file you can execute below command. Just replace ```$(FULL_CURRENT_PATH)``` with path to your source file.
 ```
 $ astyle.exe --style=kr --indent=spaces=4 --indent-switches $(FULL_CURRENT_PATH)
 ```

 ## Python coding rules & coding guidelines
 Some of our tools in workspace_tools are written in ```Python 2.7```. In case of developing tools for python we prefer to keep similar code styles across all Python source code. Please note that not all rules must be enforced. For example we do not limit you to 80 characters per line, just be sure your code can fit to widescreen display.

 Please stay compatible with ```Python 2.7``` but nothing stops you to write your code so in the future it will by Python 3 friendly.

 Please check our Python source code (especially ```test_api.py``` and ```singletest.py```) to get notion of how your new code should look like). We know our code is not perfect but please try to fit the same coding style to existing code so source looks consistent and is not series of different flavors.

 Some general guidelines:
 * Use Python idioms, please refer to one of many on-line guidelines how to write Pythonic code: [Code Like a Pythonista: Idiomatic Python](http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html).
 * Please do not use TABs. Please use 4 spaces instead for indentations.
 * Please put space character between operators, after comma etc.
 * Please document your code, write comments and ```doc``` sections for each function or class you implement.

 ### Static Code Analizers for Python
 If you are old-school developer for sure you remember tools like lint. "lint was the name originally given to a particular program that flagged some suspicious and non-portable constructs (likely to be bugs) in C language source code." Now lint-like programs are used to check similar code issues for multiple languages, also for Python. Please do use them if you want to commit new code to workspace_tools and other mbed SDK Python tooling.

 Below is the list Python lint tools you may want to use:

 * [pyflakes](https://pypi.python.org/pypi/pyflakes) - Please scan your code with pyflakes and remove all issues reported by it. If you are unsure if something should be modified or not you can skip lint report related fix and report this issue as possible additional commit in your pull request description.

 * [pylint](http://www.pylint.org/) - Please scan your code with pylint and check if there are any issues which can be resolved and are obvious "to fix" bugs. For example you may forgot to add 'self' as first parameter in class method parameter list or you are calling unknown functions / functions from not imported modules.

 * [pychecker](http://pychecker.sourceforge.net/) - optional, but more the merrier ;)

 Example Python look&feel:
 ```python
 class HostRegistry:
 """ Class stores registry with host tests and objects representing them
 """
 HOST_TESTS = {} # host_test_name -> host_test_ojbect
 
 def register_host_test(self, ht_name, ht_object):
 """ Registers (removes) host test by name from HOST_TESTS registry
 if host test is not already registered (check by name).
 """
 if ht_name not in self.HOST_TESTS:
 self.HOST_TESTS[ht_name] = ht_object
 
 def unregister_host_test(self):
 """ Unregisters (removes) host test by name from HOST_TESTS registry.
 """
 if ht_name in HOST_TESTS:
 self.HOST_TESTS[ht_name] = None
 
 def get_host_test(self, ht_name):
 """ Returns HOST_TEST if host name is valid.
 In case no host test is available return None
 """
 return self.HOST_TESTS[ht_name] if ht_name in self.HOST_TESTS else None
 
 def is_host_test(self, ht_name):
 """ Function returns True if host name is valid (is in HOST_TESTS)
 """
 return ht_name in self.HOST_TESTS
 ```

 ## Testing
 Please refer to TESTING.md document for detais regarding mbed SDK test suite and build scripts included in ```mbed/workspace_tools/```.

 ## Before pull request checklist
 * Your pull request description section contains:
 * Rationale – tell us why you submitted this pull request. This is your change to write us summary of your change.
 * Description – describe changes you’ve made and tell us which new features / functionalities were implemented.
 * Manual / Cookbook / Handbook – you can put here manual, cookbook or handbook related to your change / enhancement. Your documentation can stay with pull request.
 * Test results (if applicable).
 * Make sure you followed project's coding rules and styles.
 * No dependencies are created to external C/C++ libraries which are not included already in our repository.
 * Please make sure that in your module all functions have unique prefix (no name space collisions).
 * You reused existing functionality, please do not add or rewrite existing code. E.g. use mbed’s ```FunctionPointer``` if possible to store your function pointers. Do not write another wrapper for it. We already got one. If some functionality is missing, just add it! Extend our APIs wisely!
 * Were you consistent? Please continue using style / code formatting, variables naming etc. in file they are modifying.
 * Your code compiles and links. Also doesn’t generate additional compilation warnings.
--- a/tmk_core/tool/mbed/mbed-sdk/docs/TESTING.md
+++ b/tmk_core/tool/mbed/mbed-sdk/docs/TESTING.md
@@ -0,0 +1,877 @@
 # Mbed SDK automated test suite
 ## Introduction

 Test suit allows users to run locally on their machines Mbed SDK’s tests included in Mbed SDK repository. It also allows users to create their own tests and for example add new tests to test set as they progress with their project. If test is generic enough it could be included into official Mbed SDK test pool just do it via normal pull request!

 Each test is supervised by python script called “host test” which will at least Test suite is using build script API to compile and build test source together with required by test libraries like CMSIS, Mbed, Ethernet, USB etc.

 ## What is host test?
 Test suite supports test supervisor concept. This concept is realized by separate Python script called ```host test```. Host tests can be found in ```mbed/workspace_tools/host_tests/``` directory. Note: In newer mbed versions (mbed OS) host tests will be separate library.

 Host test script is executed in parallel with test runner to monitor test execution. Basic host test just monitors device's default serial port for test results returned by test runner. Simple tests will print test result on serial port. In other cases host tests can for example judge by test results returned by test runner is test passed or failed. It all depends on test itself.

 In some cases host test can be TCP server echoing packets from test runner and judging packet loss. In other cases it can just check if values returned from accelerometer are actually valid (sane).

 ## Test suite core: singletest.py script

 ```singletest.py``` script located in ```mbed/workspace_tools/``` is a test suite script which allows users to compile, build tests and test runners (also supports CppUTest unit test library). Script also is responsible for test execution on devices selected by configuration files.

 ### Parameters of singletest.py

 Test execution script ```singletest.py``` is a fairly powerful tool to run tests for mbed SDK platform. It is flexible and allows users to configure test execution process and define which mbed platforms will be tested.

 By specifying external configuration files (in JSON format) you can gain flexibility and prepare many different test scenarios. Just pass configuration file names to your script and run it.

 #### MUTs Specification
 You can easily configure your MUTs (Mbed Under Test) by creating configuration file with MUTs description.
 Note: This configuration file must be in [JSON format](http://www.w3schools.com/json/).
 Note: Unfortunately JSON format is not allowing you to have comments inside JSON code.

 Let’s see some example and let's try to configure small "test farm" with three devices connected to your host computer. In this example no peripherals (like SD card or EEPROM) are connected to our Mbed boards. We will use three platforms in this example:
 * [NXP LPC1768](https://mbed.org/platforms/mbed-LPC1768) board. 
 * \[Freescale KL25Z](https://mbed.org/platforms/KL25Z) board and 
 * [STMicro Nucleo F103RB](https://mbed.org/platforms/ST-Nucleo-F103RB) board. 
 After connecting boards to our host machine (PC) we can check which serial ports and disks they occupy. For our example let's assume that:
 * ```LPC1768``` serial port is on ```COM4``` and disk drive is ```J:```. 
 * ```KL25Z``` serial port is on ```COM39``` and disk drive is ```E:```. 
 * ```NUCLEO_F103RB``` serial port is on ```COM11``` and disk drive is ```I:```. 
 If you are working under Linux your port and disk could look like /dev/ttyACM5 and /media/usb5.

 This information is needed to create ```muts_all.json``` configuration file. You can create in in ```mbed/workspace_tools/``` directory:
 ```
 $ touch muts_all.json
 ```

 Its name will be passed to ```singletest.py``` script after ```-M``` (MUTs specification) switch. Let’s see how this file's content would look like in our example below:
 ```json
 {
 "1" : {"mcu": "LPC1768",
 "port":"COM4",
 "disk":"J:\\",
 "peripherals": []
 },
 
 "2" : {"mcu": "KL25Z",
 "port":"COM39",
 "disk":"E:\\",
 "peripherals": []
 },
 
 "3" : {"mcu": "NUCLEO_F103RB",
 "port":"COM11",
 "disk":"I:\\",
 "peripherals": []
 }
 }
 ```

 Note: We will leave field ```peripherals``` empty for the sake of this example. We will explain it later. All you need to do now is to properly fill fields ```mcu```, ```port``` and ```disk```. 

 Note: Please make sure files muts_all.json and test_spec.json are in workspace_tools/ directory. We will assume in this example they are.
 Where to find ```mcu``` names? You can use option ```-S``` of ```build.py``` script (in ```mbed/workspace_tools/``` directory) to check all supported off-line MCUs names.

 Note: If you update mbed device firmware or even disconnect / reconnect mbed device you may find that serial port / disk configuration changed. You need to update configuration file accordingly or you will face connection problems and obviously tests will not run.

 #### Peripherals testing
 When using MUTs configuration file (switch ```-M```) you can define in MUTs JSON file peripherals connected to your device:
 ```json
 {
 "1" : {"mcu" : "KL25Z",
 "port" : "COM39",
 "disk" : "E:\\",
 "peripherals" : ["SD", "24LC256"]}
 }
 ```
 You can force test suite to run only common tests (switch ```-C```) or only peripheral tests (switch ```-P```).
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -C
 ```
 will not include tests for SD card and EEPROM 24LC256.
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -P
 ```
 will only run tests bind to SD card and EEPROM 24LC256.

 Note: option ```-P``` is useful for example in cases when you have same platform and different shields you want to test. No need to test common part all the time (timers, RTC, RTOS etc.). You can force to test peripherals only on some devices and for example only common tests on other devices.

 #### Additional MUTs configuration file settings
 You can add extra information to each MUT configuration. In particular you can specify which flashing (binary copy method) should be used, how to reset target and for example set reset timeout (used to delay test execution just after reset).

 muts_all.json:
 ```json
 {
 "1" : {"mcu" : "LPC1768",
 "port" : "COM77",
 "disk" : "G:\\",
 "peripherals" : ["TMP102", "digital_loop", "port_loop", "analog_loop", "SD"]},
 
 "2" : {"mcu" : "KL25Z",
 "port" : "COM89",
 "disk" : "F:\\",
 "peripherals" : ["SD", "24LC256", "KL25Z"],
 "copy_method" : "copy",
 "reset_type" : "default",
 "reset_tout" : "2"},
 
 "3" : {"mcu" : "LPC11U24",
 "port" : "COM76",
 "disk" : "E:\\",
 "peripherals" : []}
 }
 ```
 Please note that for MUT no. 2 few extra parameters were defined: ```copy_method```, ```reset_type``` and ```reset_tout```. Using this extra options you can tell test suite more about MUT you are using. This will allow you to be more flexible in terms of how you configure and use your MUTs.

 * ```copy_method``` - STRING - tells test suite which binary copy method should be used.
 You may notice that ```singletest.py``` command line help contains description about:
 * Option ```-c``` (in MUTs file called ```copy_method```) with available copy methods supported by test suite plugin system. 
 * Option ```-r``` (in MUTs file called reset_type) with available reset methods supported by test suite plugin system.
 * ```reset_type``` - STRING - some boards may require special reset handling, for example vendor specific command must be executed to reset device.
 * ```reset_tout``` - INTEGER - extra timeout just after device is reseted. May be used to wait for few seconds so device may finish booting, flashing data internally etc. 

 Part of help listing for singletest.py:
 ```
 -c COPY_METHOD, --copy-method=COPY_METHOD
 Select binary copy (flash) method. Default is Python's
 shutil.copy() method. Plugin support: copy, cp,
 default, eACommander, eACommander-usb, xcopy
 -r MUT_RESET_TYPE, --reset-type=MUT_RESET_TYPE
 Extra reset method used to reset MUT by host test
 script. Plugin support: default, eACommander,
 eACommander-usb
 ```

 ----

 Now we've already defined how our devices are connected to our host PC. We can continue and define which of this MUTs will be tested and which compilers we will use to compile and build Mbed SDK and tests. To do so we need to create test specification file (let's call it ```test_spec.json```) and put inside our configuration file information about which MUTs we actually want to test. We will pass this file's name to ```singletest.py``` script using ```-i``` switch.

 Below we can see how sample ```test_spec.json``` file content could look like. (I've included all possible toolchains, we will change it in a moment):
 ```json
 {
 "targets": {
 "LPC1768" : ["ARM", "uARM", "GCC_ARM", "GCC_CS", "GCC_CR", "IAR"],
 "KL25Z" : ["ARM", "GCC_ARM"],
 "NUCLEO_F103RB" : ["ARM", "uARM"]
 }
 }
 ```
 Above example configuration will force tests for LPC1768, KL25Z, NUCLEO_F103RB platforms and:

 * Compilers: ```ARM```, ```uARM```, ```GCC_ARM```, ```GCC_CS```, ```GCC_CR``` and ```IAR``` will be used to compile tests for NXP's ```LPC1768```.
 * Compilers: ```ARM``` and ```GCC_ARM``` will be used for Freescales' ```KL25Z``` platform.
 * Compilers: ```ARM``` and ```uARM``` will be used for STMicro's ```NUCLEO_F103RB``` platform.

 For our example purposes let's assume we only have Keil ARM compiler, so let's change configuration in ```test_spec.json``` file and reduce number of compiler to those we actually have:
 ```json
 {
 "targets": {
 "LPC1768" : ["ARM", "uARM"],
 "KL25Z" : ["ARM"],
 "NUCLEO_F103RB" : ["ARM", "uARM"]
 }
 }
 ```
 #### Run your tests

 After you configure all your MUTs and compilers you are ready to run tests. Make sure your devices are connected and your configuration files reflect your current configuration (serial ports, devices). Go to workspace_tools directory in your mbed location.
 ```
 $ cd workspace_tools/
 ```
 and execute test suite script.
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json
 ```
 To check your configuration before test execution please use ```--config``` switch:
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json --config
 MUTs configuration in m.json:
 +-------+-------------+---------------+------+-------+
 | index | peripherals | mcu | disk | port |
 +-------+-------------+---------------+------+-------+
 | 1 | | LPC1768 | J:\ | COM4 |
 | 3 | | NUCLEO_F103RB | I:\ | COM11 |
 | 2 | | KL25Z | E:\ | COM39 |
 +-------+-------------+---------------+------+-------+

 Test specification in t.json:
 +---------------+-----+------+
 | mcu | ARM | uARM |
 +---------------+-----+------+
 | NUCLEO_F103RB | Yes | Yes |
 | KL25Z | Yes | - |
 | LPC1768 | Yes | Yes |
 +---------------+-----+------+
 ```
 It should help you localize basic problems with configuration files and toolchain configuration.
 Note: Configurations with issues will be marked with ```*``` sign.

 Having multiple configuration files allows you to manage your test scenarios in more flexible manner. You can:

 * Set up all platforms and toolchains used during testing.
 * Define (using script's ```-n``` switch) which tests you want to run during testing.
 * Just run regression (all tests). Regression is default setting for test script. 

 You can also force ```singletest.py``` script to:
 * Run only peripherals' tests (switch ```-P```) or
 * Just skip peripherals' tests (switch ```-C```). 
 * Build mbed SDK, libraries and corresponding tests with multiple cores, just use ```-j X``` option where ```X``` is number of cores you want to use for compilation.
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -j 8
 ```
 * Print test cases console output using ```-V``` option.
 * Only build mbed SDK, tests and dependant libraries with switch ```-O```:
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -j 8 -O
 ```
 * Execute each test case multiple times with ```--global-loops X``` option, where ```X``` number of repeats. Additionally use option ```-W``` to continue repeating test cases execution only if they continue to fail.
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json --global-loops 3 -W
 ``` 
 * Option ```--loops``` can be used to overwrite global loop count and redefine loop count for particular tests. Define test loops as ```TEST_ID=X``` where ```X``` is integer and separate loops count definitions by comma if necessary. E.g. ```TEST_1=5,TEST_2=20,TEST_3=2```. 
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json RTOS_1=10,RTOS_2=5
 ```
 This will execute test ```RTOS_1``` ten (10) times and test ```RTOS_2``` five (5) times.
 * Force non default copy method. Note that mbed platforms can be flashed with just binary drag&drop. We simply copy file onto mbed's disk and interface chip flashes target MCU with given binary. Force non standard (Python specific) copy method by using option ```-c COPY_METHOD``` where ```COPY_METHOD``` can be shell, command line copy command like: ```cp```, ```copy````, ```xcopy``` etc. Make sure those commands are available from command line!
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -c cp
 ``` 
 * Run only selected tests. You can select which tests should be executed when you run test suite. Use ```-n``` switch to define tests by their ids you want to execute. Use comma to separate test ids:
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -n RTOS_1,RTOS_2,RTOS_3,MBED_10,MBED_16,MBED_11
 ```
 * Set common output binary name for all tests. In some cases you would like to have the same name for all tests. You can use switch ```--firmware-name``` to specify (without extension) build script output binary name.
 In below example we would like to have all test binaries called ```firmware.bin`` (or with other extension like .elf, .hex depending on target accepted format).
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json --firmware-name firmware
 ```
 * Where to find test list? Tests are defined in file ```tests.py``` in ```mbed/workspace_tools/``` directory. ```singletest.py``` uses test metadata in ```tests.py``` to resolve libraries dependencies and build tests for proper platforms and peripherals. Option ```-R``` can be used to get test names and direct path and test configuration.
 ```
 $ python singletest.py -R
 +-------------+-----------+---------------------------------------+--------------+-------------------+----------+--------------------------------------------------------+
 | id | automated | description | peripherals | host_test | duration | source_dir |
 +-------------+-----------+---------------------------------------+--------------+-------------------+----------+--------------------------------------------------------+
 | MBED_1 | False | I2C SRF08 | SRF08 | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\i2c_SRF08 |
 | MBED_10 | True | Hello World | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\hello |
 | MBED_11 | True | Ticker Int | - | host_test | 20 | C:\Work\mbed\libraries\tests\mbed\ticker |
 | MBED_12 | True | C++ | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\cpp |
 | MBED_13 | False | Heap & Stack | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\heap_and_stack |
 | MBED_14 | False | Serial Interrupt | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\serial_interrupt |
 | MBED_15 | False | RPC | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\rpc |
 | MBED_16 | True | RTC | - | host_test | 15 | C:\Work\mbed\libraries\tests\mbed\rtc |
 | MBED_17 | False | Serial Interrupt 2 | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\serial_interrupt_2 |
 | MBED_18 | False | Local FS Directory | - | host_test | 10 | C:\Work\mbed\libraries\tests\mbed\dir |
 ...
 ```
 Note: you can filter tests by ```id``` column, just use ```-f``` option and give test name or regular expression:
 ```
 $ python singletest.py -R -f RTOS
 +--------------+-----------+-------------------------+-------------+-----------+----------+---------------------------------------------------+
 | id | automated | description | peripherals | host_test | duration | source_dir |
 +--------------+-----------+-------------------------+-------------+-----------+----------+---------------------------------------------------+
 | CMSIS_RTOS_1 | False | Basic | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\cmsis\basic |
 | CMSIS_RTOS_2 | False | Mutex | - | host_test | 20 | C:\Work\mbed\libraries\tests\rtos\cmsis\mutex |
 | CMSIS_RTOS_3 | False | Semaphore | - | host_test | 20 | C:\Work\mbed\libraries\tests\rtos\cmsis\semaphore |
 | CMSIS_RTOS_4 | False | Signals | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\cmsis\signals |
 | CMSIS_RTOS_5 | False | Queue | - | host_test | 20 | C:\Work\mbed\libraries\tests\rtos\cmsis\queue |
 | CMSIS_RTOS_6 | False | Mail | - | host_test | 20 | C:\Work\mbed\libraries\tests\rtos\cmsis\mail |
 | CMSIS_RTOS_7 | False | Timer | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\cmsis\timer |
 | CMSIS_RTOS_8 | False | ISR | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\cmsis\isr |
 | RTOS_1 | True | Basic thread | - | host_test | 15 | C:\Work\mbed\libraries\tests\rtos\mbed\basic |
 | RTOS_2 | True | Mutex resource lock | - | host_test | 20 | C:\Work\mbed\libraries\tests\rtos\mbed\mutex |
 | RTOS_3 | True | Semaphore resource lock | - | host_test | 20 | C:\Work\mbed\libraries\tests\rtos\mbed\semaphore |
 | RTOS_4 | True | Signals messaging | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\mbed\signals |
 | RTOS_5 | True | Queue messaging | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\mbed\queue |
 | RTOS_6 | True | Mail messaging | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\mbed\mail |
 | RTOS_7 | True | Timer | - | host_test | 15 | C:\Work\mbed\libraries\tests\rtos\mbed\timer |
 | RTOS_8 | True | ISR (Queue) | - | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\mbed\isr |
 | RTOS_9 | True | SD File write-read | SD | host_test | 10 | C:\Work\mbed\libraries\tests\rtos\mbed\file |
 +--------------+-----------+-------------------------+-------------+-----------+----------+---------------------------------------------------+
 ```

 * Shuffle your tests. We strongly encourage you to shuffle your test order each time you execute test suite script.
 Rationale: It is probable that tests executed in one particular order will pass and in other will fail. To shuffle your tests’ order please use option ```–u``` (or ```--shuffle```):
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json --shuffle
 ```
 Above command with force test script to randomly generate shuffle seed and shuffle test order execution. Note: Shuffle seed is float in ```[0.0, 1.0)```.

 You can always recreate particular test order by forcing shuffle (```-u``` or ```--shuffle```} switch) and passing shuffle seed back to test suite using ```--shuffle-seed``` switch:
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json --shuffle --shuffle-seed 0.4041028336
 ```
 Note: You can also supply your own randomly generated shuffle seed to drive particular test execution order scenarios. Just make sure shuffle seed is float in ```[0.0, 1.0)```.
 You can find test shuffle seed in test summary:
 ```
 ...
 | OK | LPC1768 | ARM | MBED_A9 | Serial Echo at 115200 | 2.84 | 10 | 1/1 |
 +--------+---------+-----------+-----------+-----------------------------+--------------------+---------------+-------+
 Result: 1 FAIL / 22 OK
 Shuffle Seed: 0.4041028336

 Completed in 234.85 sec
 ```

 ### Exmple of device configuration (one device connected to host computer)

 This example will show you how to configure single device, run general tests or only peripheral tests. We will also show some real test result examples.

 1. We will test only one board STMIcro Nucleo ```F334R8``` board connected to our PC (port ```COM46``` and disk is ```E:```).
 2. We will also connect EEPROM ```24LC256``` to SDA, SCL pins of our Nucleo board and define 24LC256 peripheral to make sure our test suite will run all available tests for ```24LC256```.

 Let's configure our one MUT and set uARM as the only compiler we will use to compiler Mbed SDK and tests.
 We also need to create two configuration files ```muts_all.json``` and ```test_spec.json``` to pass our small testbed configuration to test script. 

 muts_all.json:
 ```json
 {
 "1" : { 
 "mcu": "NUCLEO_F334R8",
 "port":"COM46",
 "disk":"E:\\",
 "peripherals": ["24LC256"]
 }
 }
 ```
 Note: By defining ```"peripherals": ["24LC256"]``` we are passing to test suite information that this particular board has EEPROM 24LC256 connected to our board. 

 test_spec.json:
 ```json
 {
 "targets": {
 "NUCLEO_F334R8" : ["uARM"]
 }
 }
 ```
 Note: 
 * Please make sure device is connected before we will start running tests.
 * Please make sure files ```muts_all.json``` and ```test_spec.json``` are in ```mbed/workspace_tools/``` directory.
 Now you can call test suite and execute tests:
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json
 ...
 Test summary:
 +--------+---------------+-----------+-----------+---------------------------------+--------------------+---------------+
 | Result | Target | Toolchain | Test ID | Test Description | Elapsed Time (sec) | Timeout (sec) |
 +--------+---------------+-----------+-----------+---------------------------------+--------------------+---------------+
 | OK | NUCLEO_F334R8 | uARM | MBED_A25 | I2C EEPROM line read/write test | 12.41 | 15 |
 | OK | NUCLEO_F334R8 | uARM | MBED_A1 | Basic | 3.42 | 10 |
 | OK | NUCLEO_F334R8 | uARM | EXAMPLE_1 | /dev/null | 3.42 | 10 |
 | OK | NUCLEO_F334R8 | uARM | MBED_24 | Timeout Int us | 11.47 | 15 |
 | OK | NUCLEO_F334R8 | uARM | MBED_25 | Time us | 11.43 | 15 |
 | OK | NUCLEO_F334R8 | uARM | MBED_26 | Integer constant division | 3.37 | 10 |
 | OK | NUCLEO_F334R8 | uARM | MBED_23 | Ticker Int us | 12.43 | 15 |
 | OK | NUCLEO_F334R8 | uARM | MBED_A19 | I2C EEPROM read/write test | 11.42 | 15 |
 | OK | NUCLEO_F334R8 | uARM | MBED_11 | Ticker Int | 12.43 | 20 |
 | OK | NUCLEO_F334R8 | uARM | MBED_10 | Hello World | 2.42 | 10 |
 | OK | NUCLEO_F334R8 | uARM | MBED_12 | C++ | 3.42 | 10 |
 | OK | NUCLEO_F334R8 | uARM | MBED_16 | RTC | 4.76 | 15 |
 | UNDEF | NUCLEO_F334R8 | uARM | MBED_2 | stdio | 20.42 | 20 |
 | UNDEF | NUCLEO_F334R8 | uARM | MBED_A9 | Serial Echo at 115200 | 10.37 | 10 |
 +--------+---------------+-----------+-----------+---------------------------------+--------------------+---------------+
 Result: 2 UNDEF / 12 OK

 Completed in 160 sec
 ```

 If we want to get additional test summary with results in separate columns please use option ```-t```.
 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -t
 ...
 Test summary:
 +---------------+-----------+---------------------------------+-------+
 | Target | Test ID | Test Description | uARM |
 +---------------+-----------+---------------------------------+-------+
 | NUCLEO_F334R8 | EXAMPLE_1 | /dev/null | OK |
 | NUCLEO_F334R8 | MBED_10 | Hello World | OK |
 | NUCLEO_F334R8 | MBED_11 | Ticker Int | OK |
 | NUCLEO_F334R8 | MBED_12 | C++ | OK |
 | NUCLEO_F334R8 | MBED_16 | RTC | OK |
 | NUCLEO_F334R8 | MBED_2 | stdio | UNDEF |
 | NUCLEO_F334R8 | MBED_23 | Ticker Int us | OK |
 | NUCLEO_F334R8 | MBED_24 | Timeout Int us | OK |
 | NUCLEO_F334R8 | MBED_25 | Time us | OK |
 | NUCLEO_F334R8 | MBED_26 | Integer constant division | OK |
 | NUCLEO_F334R8 | MBED_A1 | Basic | OK |
 | NUCLEO_F334R8 | MBED_A19 | I2C EEPROM read/write test | OK |
 | NUCLEO_F334R8 | MBED_A25 | I2C EEPROM line read/write test | OK |
 | NUCLEO_F334R8 | MBED_A9 | Serial Echo at 115200 | UNDEF |
 +---------------+-----------+---------------------------------+-------+
 ```
 ----
 Please do not forget you can combine few options together to get result you want. For example you want to repeat few tests multiple number of times, shuffle test ids execution order and select only tests which are critical for you at this point. You can do it using switch -n, --global-loops with --loops and --shuffle:

 Execute above command to:

 * Run only tests: ```RTOS_1```, ```RTOS_2```, ```RTOS_3```, ```MBED_10```, ```MBED_16```, ```MBED_11```.
 * Shuffle test execution order. Note tests in loops will not be shuffled.
 * Set global loop count to 3 - each test will repeated 3 times.
 * Overwrite global loop count (set above to 3) and:
 * Force to loop test RTOS_1 to execute 3 times.
 * Force to loop test RTOS_2 to execute 4 times.
 * Force to loop test RTOS_3 to execute 5 times.
 * Force to loop test MBED_11 to execute 5 times. 

 ```
 $ python singletest.py -i test_spec.json -M muts_all.json -n RTOS_1,RTOS_2,RTOS_3,MBED_10,MBED_16,MBED_11 --shuffle --global-loops 3 --loops RTOS_1=3,RTOS_2=4,RTOS_3=5,MBED_11=5
 ```

 # CppUTest unit test library support
 ## CppUTest in Mbed SDK testing introduction
 [CppUTest](http://cpputest.github.io/) is a C / C++ based unit xUnit test framework for unit testing and for test-driving your code. It is written in C++ but is used in C and C++ projects and frequently used in embedded systems but it works for any C / C++ project.

 Mbed SDK test suite supports writing tests using CppUTest. All you need to do it to provide CppUTest sources and includes with Mbed SDK port. This is already done for you so all you need to do it to get proper sources in your project directory.
 CppUTest’s core design principles are:
 * Simple in design and simple in use. 
 * Portable to old and new platforms. 
 * Build with Test-driven Development in mind.

 ## From where you can get more help about CppUTest library and unit testing
 • You can read [CppUTest manual](http://cpputest.github.io/manual.html)
 * [CppUTest forum](https://groups.google.com/forum/?fromgroups#!forum/cpputest) 
 * [CppUTest on GitHub](https://github.com/cpputest/cpputest)
 * Finally, if you think unit testing is new concept for you, you can have a grasp of it on Wikipedia pages about [unit testing](http://en.wikipedia.org/wiki/Unit_testing) and continue from there. 

 ## How to add CppUTest to your current Mbed SDK installation

 ### Do I need CppUTest port for Mbed SDK?
 Yes, you do. If you want to use CppUTest with Mbed SDK you need to have CppUTest version with ARMCC compiler (only ARM flavor for now) port and Mbed SDK console port (if you want to have output on serial port). All is already prepared by Mbed engineers and you can get it for example here: http://mbed.org/users/rgrover1/code/CppUTest/

 ### Prerequisites
 * Installed [git client](http://git-scm.com/downloads/).
 * Installed [Mercurial client](http://mercurial.selenic.com/).

 ### How / where to install
 We want to create directory structure similar to one below:
 ```
 \your_project_directory
 │
 ├───cpputest
 │ ├───include
 │ └───src
 └───mbed
 ├───libraries
 ├───travis
 └───workspace_tools
 ```

 Please go to directory with your project. For example it could be c:\Projects\Project.
 ```
 $ cd c:\Projects\Project
 ```
 If your project directory already has your mbed SDK repository included just execute below command (Mercurial console client). It should download CppUTest with Mbed SDK port.
 ```
 $ hg clone https://mbed.org/users/rgrover1/code/cpputest/
 ```

 You should see something like this after you execute Mercurial clone command:
 ```
 $ hg clone https://mbed.org/users/rgrover1/code/cpputest/
 destination directory: cpputest
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 3 changesets with 69 changes to 42 files
 updating to branch default
 41 files updated, 0 files merged, 0 files removed, 0 files unresolved
 ```

 Confirm your project structure. It should look more or less like this:
 ```
 $ ls
 cpputest mbed
 ```
 From now on CppUTest is in correct path. Each time you want to compile unit tests for CppUTest build script will always look for CppUTest library in the same directory where mbed library is.

 ## New off-line mbed SDK project with CppUTest support

 If you are creating new mbed SDK project and you want to use CppUTest with it you need to download both mbed SDK and CppUTest with mbed port to the same directory. You can do it like this:
 ```
 $ cd c:\Projects\Project
 $ git clone https://github.com/mbedmicro/mbed.git
 $ hg clone https://mbed.org/users/rgrover1/code/cpputest/
 ```

 After above three steps you should have proper directory structure. All you need to do now is to configure your ```private_settings.py``` in ```mbed/workspace_tools/``` directory. Please refer to mbed SDK build script documentation for details.

 ## CppUTest with mbed port 
 To make sure you actualy have CppUTest library with mbed SDK port you can go to CppUTest ```armcc``` platform directory:
 ```
 $ cd c:/Projects/Project/cpputest/src/Platforms/armcc/
 ```
 And open file ```UtestPlatform.cpp```.

 You should find part of code responsible for porting console on default serial port of the mbed device:
 ```c++
 #include "Serial.h"
 using namespace mbed;
 
 int PlatformSpecificPutchar(int c)
 {
 /* Please modify this block for test results to be reported as
 * console output. The following is a sample implementation using a
 * Serial object connected to the console. */
 #define NEED_TEST_REPORT_AS_CONSOLE_OUTPUT 1
 #if NEED_TEST_REPORT_AS_CONSOLE_OUTPUT
 extern Serial console;
 
 #define NEED_LINE_FEED_IN_ADDITION_TO_NEWLINE 1
 #if NEED_LINE_FEED_IN_ADDITION_TO_NEWLINE
 /* CppUTest emits \n line terminators in its reports; some terminals
 * need the linefeed (\r) in addition. */
 if (c == '\n') {
 console.putc('\r');
 }
 #endif /* #if NEED_LINE_FEED_IN_ADDITION_TO_NEWLINE */
 
 return (console.putc(c));
 #else /* NEED_TEST_REPORT_AS_CONSOLE_OUTPUT */
 return (0);
 #endif /* NEED_TEST_REPORT_AS_CONSOLE_OUTPUT */
 }
 ```

 You can find cpputest UT test runner main function in mbed sources: ```c:/Projects/Project/mbed/libraries/tests/utest/testrunner/testrunner.cpp```. Test runner code (in ```testrunner.cpp```) only defined console object and executes all unit tests:
 ```c++
 #include "CommandLineTestRunner.h"
 #include <stdio.h>
 #include "mbed.h"
 #include "testrunner.h"
 #include "test_env.h"

 /**
 Object 'mbed_cpputest_console' is used to show prints on console.
 It is declared in \cpputest\src\Platforms\armcc\UtestPlatform.cpp
 */
 Serial mbed_cpputest_console(STDIO_UART_TX, STDIO_UART_RX);

 int main(int ac, char** av) {
 MBED_HOSTTEST_TIMEOUT(20);
 MBED_HOSTTEST_SELECT(default_auto);
 MBED_HOSTTEST_DESCRIPTION(Unit test);
 MBED_HOSTTEST_START("UT");

 unsigned failureCount = 0;
 {
 // Some compilers may not pass ac, av so we need to supply them ourselves
 int ac = 2;
 char* av[] = {__FILE__, "-v"};
 failureCount = CommandLineTestRunner::RunAllTests(ac, av);
 }

 MBED_HOSTTEST_RESULT(failureCount == 0);
 return failureCount;
 }
 ```

 ## Unit test location
 Unit tests source code is located in below directory: ```c:/Projects/Project/mbed/libraries/tests/utest/```

 Each sub directory except testrunner contains compilable unit test source files with test groups and test cases. You can see utest structure below. Please note this is just example and in the future this directory will contain many sub directories with unit tests.
 ```
 $ c:\Projects\Project\mbed\libraries\tests\utest> tree
 utest
 ├───basic
 ├───semihost_fs
 └───testrunner
 ```

 ## Define unit tests in mbed SDK test suite structure
 All tests defined in test suite are described in ```mbed/workspace_tools/tests.py``` file. This file stores data structure ```TESTS``` which is a list of simple structures describing each test. Below you can find example of ```TESTS``` structure which is configuring one of the unit tests.
 ```
 .
 .
 .
 {
 "id": "UT_2", "description": "Semihost file system",
 "source_dir": join(TEST_DIR, "utest", "file"),
 "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
 "automated": False,
 "mcu": ["LPC1768", "LPC2368", "LPC11U24"]
 },
 .
 .
 .
 ```
 Note: In dependency section we've added library ```CPPUTEST_LIBRARY``` which is pointing build script to CppUTest library with mbed port. This is a must for unit tests to be compiled with CppUTest library.

 ### Tests are now divided into two types:
 #### 'Hello world' tests 
 First type of test cases we call 'hello world' tests. They do not dependent on CppUTest library and are monolithic programs usually composed of one main function. Yo can find this tests in below example directories:

 * ```mbed/libraries/tests/mbed/```
 * ```mbed/libraries/tests/net/```
 * ```mbed/libraries/tests/rtos/```
 * ```mbed/libraries/tests/usb/```

 Usually ‘hello world’ test cases are using ```test_env.cpp``` and ```test_env.h``` files which implement simple test framework used to communicate with host test and help test framework instrument your tests.

 Below you can see listing of ```test_env.h``` file which contains simple macro definitions used to communicate (via serial port printouts) between test case (on hardware) and host test script (on host computer). 
 Each use case should print on console basic information like:
 * Default test case timeout.
 * Which host test should be used to supervise test case execution.
 * Test description and test case ID (short identifier).

 ```c++
 .
 .
 .
 // Test result related notification functions
 void notify_start();
 void notify_completion(bool success);
 bool notify_completion_str(bool success, char* buffer);
 void notify_performance_coefficient(const char* measurement_name, const int value);
 void notify_performance_coefficient(const char* measurement_name, const unsigned int value);
 void notify_performance_coefficient(const char* measurement_name, const double value);

 // Host test auto-detection API
 void notify_host_test_name(const char *host_test);
 void notify_timeout(int timeout);
 void notify_test_id(const char *test_id);
 void notify_test_description(const char *description);

 // Host test auto-detection API
 #define MBED_HOSTTEST_START(TESTID) notify_test_id(TESTID); notify_start()
 #define MBED_HOSTTEST_SELECT(NAME) notify_host_test_name(#NAME)
 #define MBED_HOSTTEST_TIMEOUT(SECONDS) notify_timeout(SECONDS)
 #define MBED_HOSTTEST_DESCRIPTION(DESC) notify_test_description(#DESC)
 #define MBED_HOSTTEST_RESULT(RESULT) notify_completion(RESULT)

 /**
 Test auto-detection preamble example:
 main() {
 MBED_HOSTTEST_TIMEOUT(10);
 MBED_HOSTTEST_SELECT( host_test );
 MBED_HOSTTEST_DESCRIPTION(Hello World);
 MBED_HOSTTEST_START("MBED_10");
 // Proper 'host_test.py' should take over supervising of this test

 // Test code
 bool result = ...;

 MBED_HOSTTEST_RESULT(result);
 }
 */
 .
 .
 .
 ```

 Example of 'hello world' test:
 ```c++
 #include "mbed.h"
 #include "test_env.h"

 #define CUSTOM_TIME 1256729737

 int main() {
 MBED_HOSTTEST_TIMEOUT(20);
 MBED_HOSTTEST_SELECT(rtc_auto);
 MBED_HOSTTEST_DESCRIPTION(RTC);
 MBED_HOSTTEST_START("MBED_16");

 char buffer[32] = {0};
 set_time(CUSTOM_TIME); // Set RTC time to Wed, 28 Oct 2009 11:35:37
 while(1) {
 time_t seconds = time(NULL);
 strftime(buffer, 32, "%Y-%m-%d %H:%M:%S %p", localtime(&seconds));
 printf("MBED: [%ld] [%s]\r\n", seconds, buffer);
 wait(1);
 }
 }
 ```

 #### 'Unit test' test cases
 Second group of tests are unit tests. They are using CppUTest library and require you to write ```TEST_GROUP```s and ```TEST```s in your test files. Test suite will add test runner sources to your test automatically so you can concentrate on writing tests.

 Example of unit test:
 ```c++
 #include "TestHarness.h"
 #include <utility>
 #include "mbed.h"

 TEST_GROUP(BusOut_mask)
 {
 };

 TEST(BusOut_mask, led_1_2_3)
 {
 BusOut bus_data(LED1, LED2, LED3);
 CHECK_EQUAL(0x07, bus_data.mask());
 }

 TEST(BusOut_mask, led_nc_nc_nc_nc)
 {
 BusOut bus_data(NC, NC, NC, NC);
 CHECK_EQUAL(0x00, bus_data.mask());
 }

 TEST(BusOut_mask, led_1_2_3_nc_nc)
 {
 BusOut bus_data(LED1, LED2, LED3, NC, NC);
 CHECK_EQUAL(0x07, bus_data.mask());
 }

 TEST(BusOut_mask, led_1_nc_2_nc_nc_3)
 {
 BusOut bus_data(LED1, NC, LED2, NC, NC, LED3);
 CHECK_EQUAL(0x25, bus_data.mask());
 }

 ///////////////////////////////////////////////////////////////////////////////

 #ifdef MBED_OPERATORS
 TEST_GROUP(BusOut_digitalout_write)
 {
 };

 TEST(BusOut_digitalout_write, led_nc)
 {
 BusOut bus_data(NC);
 CHECK_EQUAL(false, bus_data[0].is_connected())
 }

 TEST(BusOut_digitalout_write, led_1_2_3)
 {
 BusOut bus_data(LED1, LED2, LED3);
 bus_data[0].write(1);
 bus_data[1].write(1);
 bus_data[2].write(1);
 CHECK(bus_data[0].read());
 CHECK(bus_data[1].read());
 CHECK(bus_data[2].read());
 }

 TEST(BusOut_digitalout_write, led_1_2_3_nc_nc)
 {
 BusOut bus_data(LED1, LED2, LED3, NC, NC);
 bus_data[0].write(0);
 bus_data[1].write(0);
 bus_data[2].write(0);
 CHECK(bus_data[0].read() == 0);
 CHECK(bus_data[1].read() == 0);
 CHECK(bus_data[2].read() == 0);
 }

 TEST(BusOut_digitalout_write, led_1_nc_2_nc_nc_3)
 {
 BusOut bus_data(LED1, NC, LED2, NC, NC, LED3);
 bus_data[0].write(1);
 bus_data[2].write(0);
 bus_data[5].write(0);
 CHECK(bus_data[0].read());
 CHECK(bus_data[2].read() == 0);
 CHECK(bus_data[5].read() == 0);
 }
 #endif
 ```

 ## Example
 In below example we will run two example unit tests that are now available. tests ```UT_1``` and ```UT_2``` are unit tests used for now only to check if mbed SDK works with CppUTest library and if tests are being executed. In future number of unit tests will increase, nothing is also should stop you from writing and executing your own unit tests!

 ### Example configuration
 By default unit tests ```UT_1``` and ```UT_2``` are not automated - simply test suite will ignore them. Also we do not want to create dependency to CppUTest library each time someone executes automation.

 Note: To compile ```UT_1``` and ```UT_2``` tests CppUTest library described above installation is needed and not all users wish to add UT libs to their project. Also new to mbed users may find it difficult. This is why unit testing is an extra feature active only after you deliberately install and enable needed components.

 Bellow snippet shows how to modify 'automated' flag so test suite will consider unit tests ```UT_1``` and ```UT_2``` as part of "automated test portfolio". Just change flag 'automated' from ```False``` to ```True```.

 ```tests.py``` listing related to ```UT_1``` and ```UT_2```:
 ```python
 .
 .
 .
 # CPPUTEST Library provides Unit testing Framework
 #
 # To write TESTs and TEST_GROUPs please add CPPUTEST_LIBRARY to 'dependencies'
 #
 # This will also include:
 # 1. test runner - main function with call to CommandLineTestRunner::RunAllTests(ac, av)
 # 2. Serial console object to print test result on serial port console
 #
 
 # Unit testing with cpputest library
 {
 "id": "UT_1", "description": "Basic",
 "source_dir": join(TEST_DIR, "utest", "basic"),
 "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
 "automated": True,
 },
 {
 "id": "UT_2", "description": "Semihost file system",
 "source_dir": join(TEST_DIR, "utest", "semihost_fs"),
 "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
 "automated": True,
 "mcu": ["LPC1768", "LPC2368", "LPC11U24"]
 },
 .
 .
 .
 ```

 ### Execute tests
 In my test I will use common [LPC1768](http://developer.mbed.org/platforms/mbed-LPC1768/) mbed-enabled board because unit test ```UT_2``` is checking semi-host functionality which is available on this board and handful of others.

 Configure your ```test_spec.json``` and ```muts_all.json``` files (refer to test suite build script and automation description) and set mbed disk and serial port.

 ```
 $ singletest.py -i test_spec.json -M muts_all.json -n UT_1,UT_2 -V
 Building library CMSIS (LPC1768, ARM)
 Building library MBED (LPC1768, ARM)
 Building library CPPUTEST (LPC1768, ARM)
 Building project BASIC (LPC1768, ARM)
 Executing 'python host_test.py -p COM77 -d E:\ -t 10'
 Test::Output::Start
 Host test instrumentation on port: "COM77" and disk: "E:\"
 TEST(FirstTestGroup, FirstTest) - 0 ms

 OK (1 tests, 1 ran, 3 checks, 0 ignored, 0 filtered out, 3 ms)

 {{success}}
 {{end}}
 Test::Output::Finish
 TargetTest::LPC1768::ARM::UT_1::Basic [OK] in 2.43 of 10 sec
 Building library CPPUTEST (LPC1768, ARM)
 Building project SEMIHOST_FS (LPC1768, ARM)
 Executing 'python host_test.py -p COM77 -d E:\ -t 10'
 Test::Output::Start
 Host test instrumentation on port: "COM77" and disk: "E:\"
 TEST(FirstTestGroup, FirstTest) - 9 ms

 OK (1 tests, 1 ran, 10 checks, 0 ignored, 0 filtered out, 10 ms)

 {{success}}
 {{end}}
 Test::Output::Finish
 TargetTest::LPC1768::ARM::UT_2::Semihost file system [OK] in 2.43 of 10 sec
 Test summary:
 +--------+---------+-----------+---------+----------------------+--------------------+---------------+-------+
 | Result | Target | Toolchain | Test ID | Test Description | Elapsed Time (sec) | Timeout (sec) | Loops |
 +--------+---------+-----------+---------+----------------------+--------------------+---------------+-------+
 | OK | LPC1768 | ARM | UT_1 | Basic | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | ARM | UT_2 | Semihost file system | 2.43 | 10 | 1/1 |
 +--------+---------+-----------+---------+----------------------+--------------------+---------------+-------+
 Result: 2 OK

 Completed in 12.02 sec
 ```

 You can compile unit tests using various number of supported compilers, below just few examples with working solutions:
 ```
 Test summary:
 +--------+---------+-----------+---------+----------------------+--------------------+---------------+-------+
 | Result | Target | Toolchain | Test ID | Test Description | Elapsed Time (sec) | Timeout (sec) | Loops |
 +--------+---------+-----------+---------+----------------------+--------------------+---------------+-------+
 | OK | LPC1768 | ARM | UT_1 | Basic | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | ARM | UT_2 | Semihost file system | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | uARM | UT_1 | Basic | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | uARM | UT_2 | Semihost file system | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | GCC_ARM | UT_1 | Basic | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | GCC_ARM | UT_2 | Semihost file system | 2.43 | 10 | 1/1 |
 | OK | LPC1768 | GCC_CR | UT_1 | Basic | 3.44 | 10 | 1/1 |
 | OK | LPC1768 | GCC_CR | UT_2 | Semihost file system | 3.43 | 10 | 1/1 |
 +--------+---------+-----------+---------+----------------------+--------------------+---------------+-------+
 Result: 8 OK

 Completed in 55.85 sec
 ```
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.cpp
@@ -0,0 +1,618 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBAudio.h"
 #include "USBAudio_Types.h"



 USBAudio::USBAudio(uint32_t frequency_in, uint8_t channel_nb_in, uint32_t frequency_out, uint8_t channel_nb_out, uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release) {
 mute = 0;
 volCur = 0x0080;
 volMin = 0x0000;
 volMax = 0x0100;
 volRes = 0x0004;
 available = false;

 FREQ_IN = frequency_in;
 FREQ_OUT = frequency_out;

 this->channel_nb_in = channel_nb_in;
 this->channel_nb_out = channel_nb_out;

 // stereo -> *2, mono -> *1
 PACKET_SIZE_ISO_IN = (FREQ_IN / 500) * channel_nb_in;
 PACKET_SIZE_ISO_OUT = (FREQ_OUT / 500) * channel_nb_out;

 // STEREO -> left and right
 channel_config_in = (channel_nb_in == 1) ? CHANNEL_M : CHANNEL_L + CHANNEL_R;
 channel_config_out = (channel_nb_out == 1) ? CHANNEL_M : CHANNEL_L + CHANNEL_R;

 SOF_handler = false;

 buf_stream_out = NULL;
 buf_stream_in = NULL;

 interruptOUT = false;
 writeIN = false;
 interruptIN = false;
 available = false;

 volume = 0;

 // connect the device
 USBDevice::connect();
 }

 bool USBAudio::read(uint8_t * buf) {
 buf_stream_in = buf;
 SOF_handler = false;
 while (!available || !SOF_handler);
 available = false;
 return true;
 }

 bool USBAudio::readNB(uint8_t * buf) {
 buf_stream_in = buf;
 SOF_handler = false;
 while (!SOF_handler);
 if (available) {
 available = false;
 buf_stream_in = NULL;
 return true;
 }
 return false;
 }

 bool USBAudio::readWrite(uint8_t * buf_read, uint8_t * buf_write) {
 buf_stream_in = buf_read;
 SOF_handler = false;
 writeIN = false;
 if (interruptIN) {
 USBDevice::writeNB(EP3IN, buf_write, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT);
 } else {
 buf_stream_out = buf_write;
 }
 while (!available);
 if (interruptIN) {
 while (!writeIN);
 }
 while (!SOF_handler);
 return true;
 }


 bool USBAudio::write(uint8_t * buf) {
 writeIN = false;
 SOF_handler = false;
 if (interruptIN) {
 USBDevice::writeNB(EP3IN, buf, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT);
 } else {
 buf_stream_out = buf;
 }
 while (!SOF_handler);
 if (interruptIN) {
 while (!writeIN);
 }
 return true;
 }


 float USBAudio::getVolume() {
 return (mute) ? 0.0 : volume;
 }


 bool USBAudio::EPISO_OUT_callback() {
 uint32_t size = 0;
 interruptOUT = true;
 if (buf_stream_in != NULL) {
 readEP(EP3OUT, (uint8_t *)buf_stream_in, &size, PACKET_SIZE_ISO_IN);
 available = true;
 buf_stream_in = NULL;
 }
 readStart(EP3OUT, PACKET_SIZE_ISO_IN);
 return false;
 }


 bool USBAudio::EPISO_IN_callback() {
 interruptIN = true;
 writeIN = true;
 return true;
 }



 // Called in ISR context on each start of frame
 void USBAudio::SOF(int frameNumber) {
 uint32_t size = 0;

 if (!interruptOUT) {
 // read the isochronous endpoint
 if (buf_stream_in != NULL) {
 if (USBDevice::readEP_NB(EP3OUT, (uint8_t *)buf_stream_in, &size, PACKET_SIZE_ISO_IN)) {
 if (size) {
 available = true;
 readStart(EP3OUT, PACKET_SIZE_ISO_IN);
 buf_stream_in = NULL;
 }
 }
 }
 }

 if (!interruptIN) {
 // write if needed
 if (buf_stream_out != NULL) {
 USBDevice::writeNB(EP3IN, (uint8_t *)buf_stream_out, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT);
 buf_stream_out = NULL;
 }
 }

 SOF_handler = true;
 }


 // Called in ISR context
 // Set configuration. Return false if the configuration is not supported.
 bool USBAudio::USBCallback_setConfiguration(uint8_t configuration) {
 if (configuration != DEFAULT_CONFIGURATION) {
 return false;
 }

 // Configure isochronous endpoint
 realiseEndpoint(EP3OUT, PACKET_SIZE_ISO_IN, ISOCHRONOUS);
 realiseEndpoint(EP3IN, PACKET_SIZE_ISO_OUT, ISOCHRONOUS);

 // activate readings on this endpoint
 readStart(EP3OUT, PACKET_SIZE_ISO_IN);
 return true;
 }


 // Called in ISR context
 // Set alternate setting. Return false if the alternate setting is not supported
 bool USBAudio::USBCallback_setInterface(uint16_t interface, uint8_t alternate) {
 if (interface == 0 && alternate == 0) {
 return true;
 }
 if (interface == 1 && (alternate == 0 || alternate == 1)) {
 return true;
 }
 if (interface == 2 && (alternate == 0 || alternate == 1)) {
 return true;
 }
 return false;
 }



 // Called in ISR context
 // Called by USBDevice on Endpoint0 request
 // This is used to handle extensions to standard requests and class specific requests.
 // Return true if class handles this request
 bool USBAudio::USBCallback_request() {
 bool success = false;
 CONTROL_TRANSFER * transfer = getTransferPtr();

 // Process class-specific requests
 if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {

 // Feature Unit: Interface = 0, ID = 2
 if (transfer->setup.wIndex == 0x0200) {

 // Master Channel
 if ((transfer->setup.wValue & 0xff) == 0) {

 switch (transfer->setup.wValue >> 8) {
 case MUTE_CONTROL:
 switch (transfer->setup.bRequest) {
 case REQUEST_GET_CUR:
 transfer->remaining = 1;
 transfer->ptr = &mute;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;

 case REQUEST_SET_CUR:
 transfer->remaining = 1;
 transfer->notify = true;
 transfer->direction = HOST_TO_DEVICE;
 success = true;
 break;
 default:
 break;
 }
 break;
 case VOLUME_CONTROL:
 switch (transfer->setup.bRequest) {
 case REQUEST_GET_CUR:
 transfer->remaining = 2;
 transfer->ptr = (uint8_t *)&volCur;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;
 case REQUEST_GET_MIN:
 transfer->remaining = 2;
 transfer->ptr = (uint8_t *)&volMin;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;
 case REQUEST_GET_MAX:
 transfer->remaining = 2;
 transfer->ptr = (uint8_t *)&volMax;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;
 case REQUEST_GET_RES:
 transfer->remaining = 2;
 transfer->ptr = (uint8_t *)&volRes;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;

 case REQUEST_SET_CUR:
 transfer->remaining = 2;
 transfer->notify = true;
 transfer->direction = HOST_TO_DEVICE;
 success = true;
 break;
 case REQUEST_SET_MIN:
 transfer->remaining = 2;
 transfer->notify = true;
 transfer->direction = HOST_TO_DEVICE;
 success = true;
 break;
 case REQUEST_SET_MAX:
 transfer->remaining = 2;
 transfer->notify = true;
 transfer->direction = HOST_TO_DEVICE;
 success = true;
 break;
 case REQUEST_SET_RES:
 transfer->remaining = 2;
 transfer->notify = true;
 transfer->direction = HOST_TO_DEVICE;
 success = true;
 break;
 }
 break;
 default:
 break;
 }
 }
 }
 }
 return success;
 }


 // Called in ISR context when a data OUT stage has been performed
 void USBAudio::USBCallback_requestCompleted(uint8_t * buf, uint32_t length) {
 if ((length == 1) || (length == 2)) {
 uint16_t data = (length == 1) ? *buf : *((uint16_t *)buf);
 CONTROL_TRANSFER * transfer = getTransferPtr();
 switch (transfer->setup.wValue >> 8) {
 case MUTE_CONTROL:
 switch (transfer->setup.bRequest) {
 case REQUEST_SET_CUR:
 mute = data & 0xff;
 updateVol.call();
 break;
 default:
 break;
 }
 break;
 case VOLUME_CONTROL:
 switch (transfer->setup.bRequest) {
 case REQUEST_SET_CUR:
 volCur = data;
 volume = (float)volCur/(float)volMax;
 updateVol.call();
 break;
 default:
 break;
 }
 break;
 default:
 break;
 }
 }
 }



 #define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \
 + (5 * INTERFACE_DESCRIPTOR_LENGTH) \
 + (1 * CONTROL_INTERFACE_DESCRIPTOR_LENGTH + 1) \
 + (2 * INPUT_TERMINAL_DESCRIPTOR_LENGTH) \
 + (1 * FEATURE_UNIT_DESCRIPTOR_LENGTH) \
 + (2 * OUTPUT_TERMINAL_DESCRIPTOR_LENGTH) \
 + (2 * STREAMING_INTERFACE_DESCRIPTOR_LENGTH) \
 + (2 * FORMAT_TYPE_I_DESCRIPTOR_LENGTH) \
 + (2 * (ENDPOINT_DESCRIPTOR_LENGTH + 2)) \
 + (2 * STREAMING_ENDPOINT_DESCRIPTOR_LENGTH) )

 #define TOTAL_CONTROL_INTF_LENGTH (CONTROL_INTERFACE_DESCRIPTOR_LENGTH + 1 + \
 2*INPUT_TERMINAL_DESCRIPTOR_LENGTH + \
 FEATURE_UNIT_DESCRIPTOR_LENGTH + \
 2*OUTPUT_TERMINAL_DESCRIPTOR_LENGTH)

 uint8_t * USBAudio::configurationDesc() {
 static uint8_t configDescriptor[] = {
 // Configuration 1
 CONFIGURATION_DESCRIPTOR_LENGTH, // bLength
 CONFIGURATION_DESCRIPTOR, // bDescriptorType
 LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB)
 MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB)
 0x03, // bNumInterfaces
 DEFAULT_CONFIGURATION, // bConfigurationValue
 0x00, // iConfiguration
 0x80, // bmAttributes
 50, // bMaxPower

 // Interface 0, Alternate Setting 0, Audio Control
 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x00, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x00, // bNumEndpoints
 AUDIO_CLASS, // bInterfaceClass
 SUBCLASS_AUDIOCONTROL, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0x00, // iInterface


 // Audio Control Interface
 CONTROL_INTERFACE_DESCRIPTOR_LENGTH + 1,// bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 CONTROL_HEADER, // bDescriptorSubtype
 LSB(0x0100), // bcdADC (LSB)
 MSB(0x0100), // bcdADC (MSB)
 LSB(TOTAL_CONTROL_INTF_LENGTH), // wTotalLength
 MSB(TOTAL_CONTROL_INTF_LENGTH), // wTotalLength
 0x02, // bInCollection
 0x01, // baInterfaceNr
 0x02, // baInterfaceNr

 // Audio Input Terminal (Speaker)
 INPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 CONTROL_INPUT_TERMINAL, // bDescriptorSubtype
 0x01, // bTerminalID
 LSB(TERMINAL_USB_STREAMING), // wTerminalType
 MSB(TERMINAL_USB_STREAMING), // wTerminalType
 0x00, // bAssocTerminal
 channel_nb_in, // bNrChannels
 (uint8_t)(LSB(channel_config_in)), // wChannelConfig
 (uint8_t)(MSB(channel_config_in)), // wChannelConfig
 0x00, // iChannelNames
 0x00, // iTerminal

 // Audio Feature Unit (Speaker)
 FEATURE_UNIT_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 CONTROL_FEATURE_UNIT, // bDescriptorSubtype
 0x02, // bUnitID
 0x01, // bSourceID
 0x01, // bControlSize
 CONTROL_MUTE |
 CONTROL_VOLUME, // bmaControls(0)
 0x00, // bmaControls(1)
 0x00, // iTerminal

 // Audio Output Terminal (Speaker)
 OUTPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 CONTROL_OUTPUT_TERMINAL, // bDescriptorSubtype
 0x03, // bTerminalID
 LSB(TERMINAL_SPEAKER), // wTerminalType
 MSB(TERMINAL_SPEAKER), // wTerminalType
 0x00, // bAssocTerminal
 0x02, // bSourceID
 0x00, // iTerminal


 // Audio Input Terminal (Microphone)
 INPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 CONTROL_INPUT_TERMINAL, // bDescriptorSubtype
 0x04, // bTerminalID
 LSB(TERMINAL_MICROPHONE), // wTerminalType
 MSB(TERMINAL_MICROPHONE), // wTerminalType
 0x00, // bAssocTerminal
 channel_nb_out, // bNrChannels
 (uint8_t)(LSB(channel_config_out)), // wChannelConfig
 (uint8_t)(MSB(channel_config_out)), // wChannelConfig
 0x00, // iChannelNames
 0x00, // iTerminal

 // Audio Output Terminal (Microphone)
 OUTPUT_TERMINAL_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 CONTROL_OUTPUT_TERMINAL, // bDescriptorSubtype
 0x05, // bTerminalID
 LSB(TERMINAL_USB_STREAMING), // wTerminalType
 MSB(TERMINAL_USB_STREAMING), // wTerminalType
 0x00, // bAssocTerminal
 0x04, // bSourceID
 0x00, // iTerminal






 // Interface 1, Alternate Setting 0, Audio Streaming - Zero Bandwith
 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x01, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x00, // bNumEndpoints
 AUDIO_CLASS, // bInterfaceClass
 SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0x00, // iInterface

 // Interface 1, Alternate Setting 1, Audio Streaming - Operational
 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x01, // bInterfaceNumber
 0x01, // bAlternateSetting
 0x01, // bNumEndpoints
 AUDIO_CLASS, // bInterfaceClass
 SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0x00, // iInterface

 // Audio Streaming Interface
 STREAMING_INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 STREAMING_GENERAL, // bDescriptorSubtype
 0x01, // bTerminalLink
 0x00, // bDelay
 LSB(FORMAT_PCM), // wFormatTag
 MSB(FORMAT_PCM), // wFormatTag

 // Audio Type I Format
 FORMAT_TYPE_I_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 STREAMING_FORMAT_TYPE, // bDescriptorSubtype
 FORMAT_TYPE_I, // bFormatType
 channel_nb_in, // bNrChannels
 0x02, // bSubFrameSize
 16, // bBitResolution
 0x01, // bSamFreqType
 (uint8_t)(LSB(FREQ_IN)), // tSamFreq
 (uint8_t)((FREQ_IN >> 8) & 0xff), // tSamFreq
 (uint8_t)((FREQ_IN >> 16) & 0xff), // tSamFreq

 // Endpoint - Standard Descriptor
 ENDPOINT_DESCRIPTOR_LENGTH + 2, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPISO_OUT), // bEndpointAddress
 E_ISOCHRONOUS, // bmAttributes
 (uint8_t)(LSB(PACKET_SIZE_ISO_IN)), // wMaxPacketSize
 (uint8_t)(MSB(PACKET_SIZE_ISO_IN)), // wMaxPacketSize
 0x01, // bInterval
 0x00, // bRefresh
 0x00, // bSynchAddress

 // Endpoint - Audio Streaming
 STREAMING_ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR_TYPE, // bDescriptorType
 ENDPOINT_GENERAL, // bDescriptor
 0x00, // bmAttributes
 0x00, // bLockDelayUnits
 LSB(0x0000), // wLockDelay
 MSB(0x0000), // wLockDelay







 // Interface 1, Alternate Setting 0, Audio Streaming - Zero Bandwith
 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x02, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x00, // bNumEndpoints
 AUDIO_CLASS, // bInterfaceClass
 SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0x00, // iInterface

 // Interface 1, Alternate Setting 1, Audio Streaming - Operational
 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x02, // bInterfaceNumber
 0x01, // bAlternateSetting
 0x01, // bNumEndpoints
 AUDIO_CLASS, // bInterfaceClass
 SUBCLASS_AUDIOSTREAMING, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0x00, // iInterface

 // Audio Streaming Interface
 STREAMING_INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 SUBCLASS_AUDIOCONTROL, // bDescriptorSubtype
 0x05, // bTerminalLink (output terminal microphone)
 0x01, // bDelay
 0x01, // wFormatTag
 0x00, // wFormatTag

 // Audio Type I Format
 FORMAT_TYPE_I_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType
 SUBCLASS_AUDIOSTREAMING, // bDescriptorSubtype
 FORMAT_TYPE_I, // bFormatType
 channel_nb_out, // bNrChannels
 0x02, // bSubFrameSize
 0x10, // bBitResolution
 0x01, // bSamFreqType
 (uint8_t)(LSB(FREQ_OUT)), // tSamFreq
 (uint8_t)((FREQ_OUT >> 8) & 0xff), // tSamFreq
 (uint8_t)((FREQ_OUT >> 16) & 0xff), // tSamFreq

 // Endpoint - Standard Descriptor
 ENDPOINT_DESCRIPTOR_LENGTH + 2, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPISO_IN), // bEndpointAddress
 E_ISOCHRONOUS, // bmAttributes
 (uint8_t)(LSB(PACKET_SIZE_ISO_OUT)), // wMaxPacketSize
 (uint8_t)(MSB(PACKET_SIZE_ISO_OUT)), // wMaxPacketSize
 0x01, // bInterval
 0x00, // bRefresh
 0x00, // bSynchAddress

 // Endpoint - Audio Streaming
 STREAMING_ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR_TYPE, // bDescriptorType
 ENDPOINT_GENERAL, // bDescriptor
 0x00, // bmAttributes
 0x00, // bLockDelayUnits
 LSB(0x0000), // wLockDelay
 MSB(0x0000), // wLockDelay

 // Terminator
 0 // bLength
 };
 return configDescriptor;
 }

 uint8_t * USBAudio::stringIinterfaceDesc() {
 static uint8_t stringIinterfaceDescriptor[] = {
 0x0c, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'A',0,'u',0,'d',0,'i',0,'o',0 //bString iInterface - Audio
 };
 return stringIinterfaceDescriptor;
 }

 uint8_t * USBAudio::stringIproductDesc() {
 static uint8_t stringIproductDescriptor[] = {
 0x16, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'M',0,'b',0,'e',0,'d',0,' ',0,'A',0,'u',0,'d',0,'i',0,'o',0 //bString iProduct - Mbed Audio
 };
 return stringIproductDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio.h
@@ -0,0 +1,287 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBAudio_H
 #define USBAudio_H

 /* These headers are included for child class. */
 #include "USBEndpoints.h"
 #include "USBDescriptor.h"
 #include "USBDevice_Types.h"

 #include "USBDevice.h"


 /**
 * USBAudio example
 *
 * @code
 * #include "mbed.h"
 * #include "USBAudio.h"
 *
 * Serial pc(USBTX, USBRX);
 *
 * // frequency: 48 kHz
 * #define FREQ 48000
 *
 * // 1 channel: mono
 * #define NB_CHA 1
 *
 * // length of an audio packet: each ms, we receive 48 * 16bits ->48 * 2 bytes. as there is one channel, the length will be 48 * 2 * 1
 * #define AUDIO_LENGTH_PACKET 48 * 2 * 1
 *
 * // USBAudio
 * USBAudio audio(FREQ, NB_CHA);
 *
 * int main() {
 * int16_t buf[AUDIO_LENGTH_PACKET/2];
 *
 * while (1) {
 * // read an audio packet
 * audio.read((uint8_t *)buf);
 *
 *
 * // print packet received
 * pc.printf("recv: ");
 * for(int i = 0; i < AUDIO_LENGTH_PACKET/2; i++) {
 * pc.printf("%d ", buf[i]);
 * }
 * pc.printf("\r\n");
 * }
 * }
 * @endcode
 */
 class USBAudio: public USBDevice {
 public:

 /**
 * Constructor
 *
 * @param frequency_in frequency in Hz (default: 48000)
 * @param channel_nb_in channel number (1 or 2) (default: 1)
 * @param frequency_out frequency in Hz (default: 8000)
 * @param channel_nb_out_in channel number (1 or 2) (default: 1)
 * @param vendor_id Your vendor_id
 * @param product_id Your product_id
 * @param product_release Your preoduct_release
 */
 USBAudio(uint32_t frequency_in = 48000, uint8_t channel_nb_in = 1, uint32_t frequency_out = 8000, uint8_t channel_nb_out = 1, uint16_t vendor_id = 0x7bb8, uint16_t product_id = 0x1111, uint16_t product_release = 0x0100);

 /**
 * Get current volume between 0.0 and 1.0
 *
 * @returns volume
 */
 float getVolume();

 /**
 * Read an audio packet. During a frame, only a single reading (you can't write and read an audio packet during the same frame)can be done using this method. Warning: Blocking
 *
 * @param buf pointer on a buffer which will be filled with an audio packet
 *
 * @returns true if successfull
 */
 bool read(uint8_t * buf);

 /**
 * Try to read an audio packet. During a frame, only a single reading (you can't write and read an audio packet during the same frame)can be done using this method. Warning: Non Blocking
 *
 * @param buf pointer on a buffer which will be filled if an audio packet is available
 *
 * @returns true if successfull
 */
 bool readNB(uint8_t * buf);

 /**
 * Write an audio packet. During a frame, only a single writing (you can't write and read an audio packet during the same frame)can be done using this method.
 *
 * @param buf pointer on the audio packet which will be sent
 * @returns true if successful
 */
 bool write(uint8_t * buf);

 /**
 * Write and read an audio packet at the same time (on the same frame)
 *
 * @param buf_read pointer on a buffer which will be filled with an audio packet
 * @param buf_write pointer on the audio packet which will be sent
 * @returns true if successful
 */
 bool readWrite(uint8_t * buf_read, uint8_t * buf_write);


 /** attach a handler to update the volume
 *
 * @param function Function to attach
 *
 */
 void attach(void(*fptr)(void)) {
 updateVol.attach(fptr);
 }

 /** Attach a nonstatic void/void member function to update the volume
 *
 * @param tptr Object pointer
 * @param mptr Member function pointer
 *
 */
 template<typename T>
 void attach(T *tptr, void(T::*mptr)(void)) {
 updateVol.attach(tptr, mptr);
 }


 protected:

 /*
 * Called by USBDevice layer. Set configuration of the device.
 * For instance, you can add all endpoints that you need on this function.
 *
 * @param configuration Number of the configuration
 * @returns true if class handles this request
 */
 virtual bool USBCallback_setConfiguration(uint8_t configuration);

 /*
 * Called by USBDevice on Endpoint0 request. Warning: Called in ISR context
 * This is used to handle extensions to standard requests
 * and class specific requests
 *
 * @returns true if class handles this request
 */
 virtual bool USBCallback_request();

 /*
 * Get string product descriptor
 *
 * @returns pointer to the string product descriptor
 */
 virtual uint8_t * stringIproductDesc();

 /*
 * Get string interface descriptor
 *
 * @returns pointer to the string interface descriptor
 */
 virtual uint8_t * stringIinterfaceDesc();

 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();

 /*
 * Called by USBDevice layer. Set interface/alternate of the device.
 *
 * @param interface Number of the interface to be configured
 * @param alternate Number of the alternate to be configured
 * @returns true if class handles this request
 */
 virtual bool USBCallback_setInterface(uint16_t interface, uint8_t alternate);

 /*
 * Called by USBDevice on Endpoint0 request completion
 * if the 'notify' flag has been set to true. Warning: Called in ISR context
 *
 * In this case it is used to indicate that a HID report has
 * been received from the host on endpoint 0
 *
 * @param buf buffer received on endpoint 0
 * @param length length of this buffer
 */
 virtual void USBCallback_requestCompleted(uint8_t * buf, uint32_t length);

 /*
 * Callback called on each Start of Frame event
 */
 virtual void SOF(int frameNumber);

 /*
 * Callback called when a packet is received
 */
 virtual bool EPISO_OUT_callback();

 /*
 * Callback called when a packet has been sent
 */
 virtual bool EPISO_IN_callback();

 private:

 // stream available ?
 volatile bool available;

 // interrupt OUT has been received
 volatile bool interruptOUT;

 // interrupt IN has been received
 volatile bool interruptIN;

 // audio packet has been written
 volatile bool writeIN;

 // FREQ
 uint32_t FREQ_OUT;
 uint32_t FREQ_IN;

 // size of the maximum packet for the isochronous endpoint
 uint32_t PACKET_SIZE_ISO_IN;
 uint32_t PACKET_SIZE_ISO_OUT;

 // mono, stereo,...
 uint8_t channel_nb_in;
 uint8_t channel_nb_out;

 // channel config: master, left, right
 uint8_t channel_config_in;
 uint8_t channel_config_out;

 // mute state
 uint8_t mute;

 // Volume Current Value
 uint16_t volCur;

 // Volume Minimum Value
 uint16_t volMin;

 // Volume Maximum Value
 uint16_t volMax;

 // Volume Resolution
 uint16_t volRes;

 // Buffer containing one audio packet (to be read)
 volatile uint8_t * buf_stream_in;

 // Buffer containing one audio packet (to be written)
 volatile uint8_t * buf_stream_out;

 // callback to update volume
 FunctionPointer updateVol;

 // boolean showing that the SOF handler has been called. Useful for readNB.
 volatile bool SOF_handler;

 volatile float volume;

 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio_Types.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBAudio/USBAudio_Types.h
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_function_api.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_function_version.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_api.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_api.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_dmacdrv.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_function_dmacdrv.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dataio.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dma.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_dma.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_intrn.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_intrn.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_lib.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_function_lib.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_api.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_api.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_controlrw.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_controlrw.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_global.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_global.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sig.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sig.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sub.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/function/usb0_function_sub.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_dmacdrv.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_dmacdrv.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_userdef.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/userdef/usb0_function_userdef.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_api.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_api.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_dmacdrv.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/inc/usb1_function_dmacdrv.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dataio.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dataio.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dma.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_dma.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_intrn.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_intrn.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_lib.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/common/usb1_function_lib.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_api.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_api.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_controlrw.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_controlrw.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_global.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_global.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sig.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sig.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sub.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/function/usb1_function_sub.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_dmacdrv.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_dmacdrv.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_userdef.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb1/src/userdef/usb1_function_userdef.c
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb_function_setting.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/TARGET_RENESAS/TARGET_RZ_A1H/usb_function_setting.h
@@ -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 */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDescriptor.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDescriptor.h
@@ -0,0 +1,74 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 /* Standard descriptor types */
 #define DEVICE_DESCRIPTOR (1)
 #define CONFIGURATION_DESCRIPTOR (2)
 #define STRING_DESCRIPTOR (3)
 #define INTERFACE_DESCRIPTOR (4)
 #define ENDPOINT_DESCRIPTOR (5)
 #define QUALIFIER_DESCRIPTOR (6)

 /* Standard descriptor lengths */
 #define DEVICE_DESCRIPTOR_LENGTH (0x12)
 #define CONFIGURATION_DESCRIPTOR_LENGTH (0x09)
 #define INTERFACE_DESCRIPTOR_LENGTH (0x09)
 #define ENDPOINT_DESCRIPTOR_LENGTH (0x07)


 /*string offset*/
 #define STRING_OFFSET_LANGID (0)
 #define STRING_OFFSET_IMANUFACTURER (1)
 #define STRING_OFFSET_IPRODUCT (2)
 #define STRING_OFFSET_ISERIAL (3)
 #define STRING_OFFSET_ICONFIGURATION (4)
 #define STRING_OFFSET_IINTERFACE (5)

 /* USB Specification Release Number */
 #define USB_VERSION_2_0 (0x0200)

 /* Least/Most significant byte of short integer */
 #define LSB(n) ((n)&0xff)
 #define MSB(n) (((n)&0xff00)>>8)

 /* Convert physical endpoint number to descriptor endpoint number */
 #define PHY_TO_DESC(endpoint) (((endpoint)>>1) | (((endpoint) & 1) ? 0x80:0))

 /* bmAttributes in configuration descriptor */
 /* C_RESERVED must always be set */
 #define C_RESERVED (1U<<7)
 #define C_SELF_POWERED (1U<<6)
 #define C_REMOTE_WAKEUP (1U<<5)

 /* bMaxPower in configuration descriptor */
 #define C_POWER(mA) ((mA)/2)

 /* bmAttributes in endpoint descriptor */
 #define E_CONTROL (0x00)
 #define E_ISOCHRONOUS (0x01)
 #define E_BULK (0x02)
 #define E_INTERRUPT (0x03)

 /* For isochronous endpoints only: */
 #define E_NO_SYNCHRONIZATION (0x00)
 #define E_ASYNCHRONOUS (0x04)
 #define E_ADAPTIVE (0x08)
 #define E_SYNCHRONOUS (0x0C)
 #define E_DATA (0x00)
 #define E_FEEDBACK (0x10)
 #define E_IMPLICIT_FEEDBACK (0x20)
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.cpp
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice.h
@@ -0,0 +1,271 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBDEVICE_H
 #define USBDEVICE_H

 #include "mbed.h"
 #include "USBDevice_Types.h"
 #include "USBHAL.h"

 class USBDevice: public USBHAL
 {
 public:
 USBDevice(uint16_t vendor_id, uint16_t product_id, uint16_t product_release);

 /*
 * Check if the device is configured
 *
 * @returns true if configured, false otherwise
 */
 bool configured(void);

 /*
 * Connect a device
 *
 * @param blocking: block if not configured
 */
 void connect(bool blocking = true);

 /*
 * Disconnect a device
 */
 void disconnect(void);

 /*
 * Add an endpoint
 *
 * @param endpoint endpoint which will be added
 * @param maxPacket Maximum size of a packet which can be sent for this endpoint
 * @returns true if successful, false otherwise
 */
 bool addEndpoint(uint8_t endpoint, uint32_t maxPacket);

 /*
 * Start a reading on a certain endpoint.
 * You can access the result of the reading by USBDevice_read
 *
 * @param endpoint endpoint which will be read
 * @param maxSize the maximum length that can be read
 * @return true if successful
 */
 bool readStart(uint8_t endpoint, uint32_t maxSize);

 /*
 * Read a certain endpoint. Before calling this function, USBUSBDevice_readStart
 * must be called.
 *
 * Warning: blocking
 *
 * @param endpoint endpoint which will be read
 * @param buffer buffer will be filled with the data received
 * @param size the number of bytes read will be stored in *size
 * @param maxSize the maximum length that can be read
 * @returns true if successful
 */
 bool readEP(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize);

 /*
 * Read a certain endpoint.
 *
 * Warning: non blocking
 *
 * @param endpoint endpoint which will be read
 * @param buffer buffer will be filled with the data received (if data are available)
 * @param size the number of bytes read will be stored in *size
 * @param maxSize the maximum length that can be read
 * @returns true if successful
 */
 bool readEP_NB(uint8_t endpoint, uint8_t * buffer, uint32_t * size, uint32_t maxSize);

 /*
 * Write a certain endpoint.
 *
 * Warning: blocking
 *
 * @param endpoint endpoint to write
 * @param buffer data contained in buffer will be write
 * @param size the number of bytes to write
 * @param maxSize the maximum length that can be written on this endpoint
 */
 bool write(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize);


 /*
 * Write a certain endpoint.
 *
 * Warning: non blocking
 *
 * @param endpoint endpoint to write
 * @param buffer data contained in buffer will be write
 * @param size the number of bytes to write
 * @param maxSize the maximum length that can be written on this endpoint
 */
 bool writeNB(uint8_t endpoint, uint8_t * buffer, uint32_t size, uint32_t maxSize);


 /*
 * Called by USBDevice layer on bus reset. Warning: Called in ISR context
 *
 * May be used to reset state
 */
 virtual void USBCallback_busReset(void) {};

 /*
 * Called by USBDevice on Endpoint0 request. Warning: Called in ISR context
 * This is used to handle extensions to standard requests
 * and class specific requests
 *
 * @returns true if class handles this request
 */
 virtual bool USBCallback_request() { return false; };

 /*
 * Called by USBDevice on Endpoint0 request completion
 * if the 'notify' flag has been set to true. Warning: Called in ISR context
 *
 * In this case it is used to indicate that a HID report has
 * been received from the host on endpoint 0
 *
 * @param buf buffer received on endpoint 0
 * @param length length of this buffer
 */
 virtual void USBCallback_requestCompleted(uint8_t * buf, uint32_t length) {};

 /*
 * Called by USBDevice layer. Set configuration of the device.
 * For instance, you can add all endpoints that you need on this function.
 *
 * @param configuration Number of the configuration
 */
 virtual bool USBCallback_setConfiguration(uint8_t configuration) { return false; };

 /*
 * Called by USBDevice layer. Set interface/alternate of the device.
 *
 * @param interface Number of the interface to be configured
 * @param alternate Number of the alternate to be configured
 * @returns true if class handles this request
 */
 virtual bool USBCallback_setInterface(uint16_t interface, uint8_t alternate) { return false; };

 /*
 * Get device descriptor. Warning: this method has to store the length of the report descriptor in reportLength.
 *
 * @returns pointer to the device descriptor
 */
 virtual uint8_t * deviceDesc();

 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc(){return NULL;};

 /*
 * Get string lang id descriptor
 *
 * @return pointer to the string lang id descriptor
 */
 virtual uint8_t * stringLangidDesc();

 /*
 * Get string manufacturer descriptor
 *
 * @returns pointer to the string manufacturer descriptor
 */
 virtual uint8_t * stringImanufacturerDesc();

 /*
 * Get string product descriptor
 *
 * @returns pointer to the string product descriptor
 */
 virtual uint8_t * stringIproductDesc();

 /*
 * Get string serial descriptor
 *
 * @returns pointer to the string serial descriptor
 */
 virtual uint8_t * stringIserialDesc();

 /*
 * Get string configuration descriptor
 *
 * @returns pointer to the string configuration descriptor
 */
 virtual uint8_t * stringIConfigurationDesc();

 /*
 * Get string interface descriptor
 *
 * @returns pointer to the string interface descriptor
 */
 virtual uint8_t * stringIinterfaceDesc();

 /*
 * Get the length of the report descriptor
 *
 * @returns length of the report descriptor
 */
 virtual uint16_t reportDescLength() { return 0; };



 protected:
 virtual void busReset(void);
 virtual void EP0setupCallback(void);
 virtual void EP0out(void);
 virtual void EP0in(void);
 virtual void connectStateChanged(unsigned int connected);
 virtual void suspendStateChanged(unsigned int suspended);
 uint8_t * findDescriptor(uint8_t descriptorType);
 CONTROL_TRANSFER * getTransferPtr(void);

 uint16_t VENDOR_ID;
 uint16_t PRODUCT_ID;
 uint16_t PRODUCT_RELEASE;

 private:
 bool addRateFeedbackEndpoint(uint8_t endpoint, uint32_t maxPacket);
 bool requestGetDescriptor(void);
 bool controlOut(void);
 bool controlIn(void);
 bool requestSetAddress(void);
 bool requestSetConfiguration(void);
 bool requestSetFeature(void);
 bool requestClearFeature(void);
 bool requestGetStatus(void);
 bool requestSetup(void);
 bool controlSetup(void);
 void decodeSetupPacket(uint8_t *data, SETUP_PACKET *packet);
 bool requestGetConfiguration(void);
 bool requestGetInterface(void);
 bool requestSetInterface(void);

 CONTROL_TRANSFER transfer;
 USB_DEVICE device;

 uint16_t currentInterface;
 uint8_t currentAlternate;
 };


 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice_Types.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBDevice_Types.h
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints.h
@@ -0,0 +1,56 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBENDPOINTS_H
 #define USBENDPOINTS_H

 /* SETUP packet size */
 #define SETUP_PACKET_SIZE (8)

 /* Options flags for configuring endpoints */
 #define DEFAULT_OPTIONS (0)
 #define SINGLE_BUFFERED (1U << 0)
 #define ISOCHRONOUS (1U << 1)
 #define RATE_FEEDBACK_MODE (1U << 2) /* Interrupt endpoints only */

 /* Endpoint transfer status, for endpoints > 0 */
 typedef enum {
 EP_COMPLETED, /* Transfer completed */
 EP_PENDING, /* Transfer in progress */
 EP_INVALID, /* Invalid parameter */
 EP_STALLED, /* Endpoint stalled */
 } EP_STATUS;

 /* Include configuration for specific target */
 #if defined(TARGET_LPC1768) || defined(TARGET_LPC2368) || defined(TARGET_LPC4088) || defined(TARGET_LPC4088_DM)
 #include "USBEndpoints_LPC17_LPC23.h"
 #elif defined(TARGET_LPC11UXX) || defined(TARGET_LPC1347) || defined (TARGET_LPC11U6X) || defined (TARGET_LPC1549)
 #include "USBEndpoints_LPC11U.h"
 #elif defined(TARGET_KL25Z) | defined(TARGET_KL43Z) | defined(TARGET_KL46Z) | defined(TARGET_K20D50M) | defined(TARGET_K64F) | defined(TARGET_K22F) | defined(TARGET_TEENSY3_1)
 #include "USBEndpoints_KL25Z.h"
 #elif defined (TARGET_STM32F4)
 #include "USBEndpoints_STM32F4.h"
 #elif defined (TARGET_RZ_A1H)
 #include "USBEndpoints_RZ_A1H.h"
 #elif defined(TARGET_Maxim)
 #include "USBEndpoints_Maxim.h"
 #else
 #error "Unknown target type"
 #endif

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_KL25Z.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_KL25Z.h
@@ -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)
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC11U.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC11U.h
@@ -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)
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC17_LPC23.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_LPC17_LPC23.h
@@ -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)
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_Maxim.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_Maxim.h
@@ -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)
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_RZ_A1H.h
@@ -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*/
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_STM32F4.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBEndpoints_STM32F4.h
@@ -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)
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL.h
@@ -0,0 +1,121 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBBUSINTERFACE_H
 #define USBBUSINTERFACE_H

 #include "mbed.h"
 #include "USBEndpoints.h"
 #include "toolchain.h"

 //#ifdef __GNUC__
 //#define __packed __attribute__ ((__packed__))
 //#endif

 class USBHAL {
 public:
 /* Configuration */
 USBHAL();
 ~USBHAL();
 void connect(void);
 void disconnect(void);
 void configureDevice(void);
 void unconfigureDevice(void);
 void setAddress(uint8_t address);
 void remoteWakeup(void);

 /* Endpoint 0 */
 void EP0setup(uint8_t *buffer);
 void EP0read(void);
 void EP0readStage(void);
 uint32_t EP0getReadResult(uint8_t *buffer);
 void EP0write(uint8_t *buffer, uint32_t size);
 void EP0getWriteResult(void);
 void EP0stall(void);

 /* Other endpoints */
 EP_STATUS endpointRead(uint8_t endpoint, uint32_t maximumSize);
 EP_STATUS endpointReadResult(uint8_t endpoint, uint8_t *data, uint32_t *bytesRead);
 EP_STATUS endpointWrite(uint8_t endpoint, uint8_t *data, uint32_t size);
 EP_STATUS endpointWriteResult(uint8_t endpoint);
 void stallEndpoint(uint8_t endpoint);
 void unstallEndpoint(uint8_t endpoint);
 bool realiseEndpoint(uint8_t endpoint, uint32_t maxPacket, uint32_t options);
 bool getEndpointStallState(unsigned char endpoint);
 uint32_t endpointReadcore(uint8_t endpoint, uint8_t *buffer);

 protected:
 virtual void busReset(void){};
 virtual void EP0setupCallback(void){};
 virtual void EP0out(void){};
 virtual void EP0in(void){};
 virtual void connectStateChanged(unsigned int connected){};
 virtual void suspendStateChanged(unsigned int suspended){};
 virtual void SOF(int frameNumber){};

 virtual bool EP1_OUT_callback(){return false;};
 virtual bool EP1_IN_callback(){return false;};
 virtual bool EP2_OUT_callback(){return false;};
 virtual bool EP2_IN_callback(){return false;};
 virtual bool EP3_OUT_callback(){return false;};
 virtual bool EP3_IN_callback(){return false;};
 #if !defined(TARGET_STM32F4)
 virtual bool EP4_OUT_callback(){return false;};
 virtual bool EP4_IN_callback(){return false;};
 #if !(defined(TARGET_LPC11UXX) || defined(TARGET_LPC11U6X) || defined(TARGET_LPC1347) || defined(TARGET_LPC1549))
 virtual bool EP5_OUT_callback(){return false;};
 virtual bool EP5_IN_callback(){return false;};
 virtual bool EP6_OUT_callback(){return false;};
 virtual bool EP6_IN_callback(){return false;};
 virtual bool EP7_OUT_callback(){return false;};
 virtual bool EP7_IN_callback(){return false;};
 virtual bool EP8_OUT_callback(){return false;};
 virtual bool EP8_IN_callback(){return false;};
 virtual bool EP9_OUT_callback(){return false;};
 virtual bool EP9_IN_callback(){return false;};
 virtual bool EP10_OUT_callback(){return false;};
 virtual bool EP10_IN_callback(){return false;};
 virtual bool EP11_OUT_callback(){return false;};
 virtual bool EP11_IN_callback(){return false;};
 virtual bool EP12_OUT_callback(){return false;};
 virtual bool EP12_IN_callback(){return false;};
 virtual bool EP13_OUT_callback(){return false;};
 virtual bool EP13_IN_callback(){return false;};
 virtual bool EP14_OUT_callback(){return false;};
 virtual bool EP14_IN_callback(){return false;};
 virtual bool EP15_OUT_callback(){return false;};
 virtual bool EP15_IN_callback(){return false;};
 #endif
 #endif

 private:
 void usbisr(void);
 static void _usbisr(void);
 static USBHAL * instance;

 #if defined(TARGET_LPC11UXX) || defined(TARGET_LPC11U6X) || defined(TARGET_LPC1347) || defined(TARGET_LPC1549)
 bool (USBHAL::*epCallback[10 - 2])(void);
 #elif defined(TARGET_STM32F4)
 bool (USBHAL::*epCallback[8 - 2])(void);
 #else
 bool (USBHAL::*epCallback[32 - 2])(void);
 #endif


 };
 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_KL25Z.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_KL25Z.cpp
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC11U.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC11U.cpp
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC17.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC17.cpp
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC40.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_LPC40.cpp
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_Maxim.cpp
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_RZ_A1H.cpp
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_STM32F4.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBHAL_STM32F4.cpp
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBRegs_STM32.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBDevice/USBRegs_STM32.h
@@ -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****/

--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.cpp
@@ -0,0 +1,276 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBHAL.h"
 #include "USBHID.h"


 USBHID::USBHID(uint8_t output_report_length, uint8_t input_report_length, uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect): USBDevice(vendor_id, product_id, product_release)
 {
 output_length = output_report_length;
 input_length = input_report_length;
 if(connect) {
 USBDevice::connect();
 }
 }


 bool USBHID::send(HID_REPORT *report)
 {
 return write(EPINT_IN, report->data, report->length, MAX_HID_REPORT_SIZE);
 }

 bool USBHID::sendNB(HID_REPORT *report)
 {
 return writeNB(EPINT_IN, report->data, report->length, MAX_HID_REPORT_SIZE);
 }


 bool USBHID::read(HID_REPORT *report)
 {
 uint32_t bytesRead = 0;
 bool result;
 result = USBDevice::readEP(EPINT_OUT, report->data, &bytesRead, MAX_HID_REPORT_SIZE);
 if(!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
 return false;
 report->length = bytesRead;
 return result;
 }


 bool USBHID::readNB(HID_REPORT *report)
 {
 uint32_t bytesRead = 0;
 bool result;
 result = USBDevice::readEP_NB(EPINT_OUT, report->data, &bytesRead, MAX_HID_REPORT_SIZE);
 // if readEP_NB did not succeed, does not issue a readStart
 if (!result)
 return false;
 report->length = bytesRead;
 if(!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
 return false;
 return result;
 }


 uint16_t USBHID::reportDescLength() {
 reportDesc();
 return reportLength;
 }



 //
 // Route callbacks from lower layers to class(es)
 //


 // Called in ISR context
 // Called by USBDevice on Endpoint0 request
 // This is used to handle extensions to standard requests
 // and class specific requests
 // Return true if class handles this request
 bool USBHID::USBCallback_request() {
 bool success = false;
 CONTROL_TRANSFER * transfer = getTransferPtr();
 uint8_t *hidDescriptor;

 // Process additional standard requests

 if ((transfer->setup.bmRequestType.Type == STANDARD_TYPE))
 {
 switch (transfer->setup.bRequest)
 {
 case GET_DESCRIPTOR:
 switch (DESCRIPTOR_TYPE(transfer->setup.wValue))
 {
 case REPORT_DESCRIPTOR:
 if ((reportDesc() != NULL) \
 && (reportDescLength() != 0))
 {
 transfer->remaining = reportDescLength();
 transfer->ptr = reportDesc();
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 }
 break;
 case HID_DESCRIPTOR:
 // Find the HID descriptor, after the configuration descriptor
 hidDescriptor = findDescriptor(HID_DESCRIPTOR);
 if (hidDescriptor != NULL)
 {
 transfer->remaining = HID_DESCRIPTOR_LENGTH;
 transfer->ptr = hidDescriptor;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 }
 break;

 default:
 break;
 }
 break;
 default:
 break;
 }
 }

 // Process class-specific requests

 if (transfer->setup.bmRequestType.Type == CLASS_TYPE)
 {
 switch (transfer->setup.bRequest)
 {
 case SET_REPORT:
 // First byte will be used for report ID
 outputReport.data[0] = transfer->setup.wValue & 0xff;
 outputReport.length = transfer->setup.wLength + 1;

 transfer->remaining = sizeof(outputReport.data) - 1;
 transfer->ptr = &outputReport.data[1];
 transfer->direction = HOST_TO_DEVICE;
 transfer->notify = true;
 success = true;
 default:
 break;
 }
 }

 return success;
 }


 #define DEFAULT_CONFIGURATION (1)


 // Called in ISR context
 // Set configuration. Return false if the
 // configuration is not supported
 bool USBHID::USBCallback_setConfiguration(uint8_t configuration) {
 if (configuration != DEFAULT_CONFIGURATION) {
 return false;
 }

 // Configure endpoints > 0
 addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT);
 addEndpoint(EPINT_OUT, MAX_PACKET_SIZE_EPINT);

 // We activate the endpoint to be able to recceive data
 readStart(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
 return true;
 }


 uint8_t * USBHID::stringIinterfaceDesc() {
 static uint8_t stringIinterfaceDescriptor[] = {
 0x08, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'H',0,'I',0,'D',0, //bString iInterface - HID
 };
 return stringIinterfaceDescriptor;
 }

 uint8_t * USBHID::stringIproductDesc() {
 static uint8_t stringIproductDescriptor[] = {
 0x16, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'H',0,'I',0,'D',0,' ',0,'D',0,'E',0,'V',0,'I',0,'C',0,'E',0 //bString iProduct - HID device
 };
 return stringIproductDescriptor;
 }



 uint8_t * USBHID::reportDesc() {
 static uint8_t reportDescriptor[] = {
 0x06, LSB(0xFFAB), MSB(0xFFAB),
 0x0A, LSB(0x0200), MSB(0x0200),
 0xA1, 0x01, // Collection 0x01
 0x75, 0x08, // report size = 8 bits
 0x15, 0x00, // logical minimum = 0
 0x26, 0xFF, 0x00, // logical maximum = 255
 0x95, input_length, // report count
 0x09, 0x01, // usage
 0x81, 0x02, // Input (array)
 0x95, output_length,// report count
 0x09, 0x02, // usage
 0x91, 0x02, // Output (array)
 0xC0 // end collection

 };
 reportLength = sizeof(reportDescriptor);
 return reportDescriptor;
 }

 #define DEFAULT_CONFIGURATION (1)
 #define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \
 + (1 * INTERFACE_DESCRIPTOR_LENGTH) \
 + (1 * HID_DESCRIPTOR_LENGTH) \
 + (2 * ENDPOINT_DESCRIPTOR_LENGTH))

 uint8_t * USBHID::configurationDesc() {
 static uint8_t configurationDescriptor[] = {
 CONFIGURATION_DESCRIPTOR_LENGTH,// bLength
 CONFIGURATION_DESCRIPTOR, // bDescriptorType
 LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB)
 MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB)
 0x01, // bNumInterfaces
 DEFAULT_CONFIGURATION, // bConfigurationValue
 0x00, // iConfiguration
 C_RESERVED | C_SELF_POWERED, // bmAttributes
 C_POWER(0), // bMaxPower

 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x00, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x02, // bNumEndpoints
 HID_CLASS, // bInterfaceClass
 HID_SUBCLASS_NONE, // bInterfaceSubClass
 HID_PROTOCOL_NONE, // bInterfaceProtocol
 0x00, // iInterface

 HID_DESCRIPTOR_LENGTH, // bLength
 HID_DESCRIPTOR, // bDescriptorType
 LSB(HID_VERSION_1_11), // bcdHID (LSB)
 MSB(HID_VERSION_1_11), // bcdHID (MSB)
 0x00, // bCountryCode
 0x01, // bNumDescriptors
 REPORT_DESCRIPTOR, // bDescriptorType
 (uint8_t)(LSB(this->reportDescLength())), // wDescriptorLength (LSB)
 (uint8_t)(MSB(this->reportDescLength())), // wDescriptorLength (MSB)

 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_IN), // bEndpointAddress
 E_INTERRUPT, // bmAttributes
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 1, // bInterval (milliseconds)

 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_OUT), // bEndpointAddress
 E_INTERRUPT, // bmAttributes
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 1, // bInterval (milliseconds)
 };
 return configurationDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID.h
@@ -0,0 +1,172 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USB_HID_H
 #define USB_HID_H

 /* These headers are included for child class. */
 #include "USBEndpoints.h"
 #include "USBDescriptor.h"
 #include "USBDevice_Types.h"

 #include "USBHID_Types.h"
 #include "USBDevice.h"


 /**
 * USBHID example
 * @code
 * #include "mbed.h"
 * #include "USBHID.h"
 *
 * USBHID hid;
 * HID_REPORT recv;
 * BusOut leds(LED1,LED2,LED3,LED4);
 *
 * int main(void) {
 * while (1) {
 * hid.read(&recv);
 * leds = recv.data[0];
 * }
 * }
 * @endcode
 */

 class USBHID: public USBDevice {
 public:

 /**
 * Constructor
 *
 * @param output_report_length Maximum length of a sent report (up to 64 bytes) (default: 64 bytes)
 * @param input_report_length Maximum length of a received report (up to 64 bytes) (default: 64 bytes)
 * @param vendor_id Your vendor_id
 * @param product_id Your product_id
 * @param product_release Your preoduct_release
 * @param connect Connect the device
 */
 USBHID(uint8_t output_report_length = 64, uint8_t input_report_length = 64, uint16_t vendor_id = 0x1234, uint16_t product_id = 0x0006, uint16_t product_release = 0x0001, bool connect = true);


 /**
 * Send a Report. warning: blocking
 *
 * @param report Report which will be sent (a report is defined by all data and the length)
 * @returns true if successful
 */
 bool send(HID_REPORT *report);


 /**
 * Send a Report. warning: non blocking
 *
 * @param report Report which will be sent (a report is defined by all data and the length)
 * @returns true if successful
 */
 bool sendNB(HID_REPORT *report);

 /**
 * Read a report: blocking
 *
 * @param report pointer to the report to fill
 * @returns true if successful
 */
 bool read(HID_REPORT * report);

 /**
 * Read a report: non blocking
 *
 * @param report pointer to the report to fill
 * @returns true if successful
 */
 bool readNB(HID_REPORT * report);

 protected:
 uint16_t reportLength;

 /*
 * Get the Report descriptor
 *
 * @returns pointer to the report descriptor
 */
 virtual uint8_t * reportDesc();

 /*
 * Get the length of the report descriptor
 *
 * @returns the length of the report descriptor
 */
 virtual uint16_t reportDescLength();

 /*
 * Get string product descriptor
 *
 * @returns pointer to the string product descriptor
 */
 virtual uint8_t * stringIproductDesc();

 /*
 * Get string interface descriptor
 *
 * @returns pointer to the string interface descriptor
 */
 virtual uint8_t * stringIinterfaceDesc();

 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();


 /*
 * HID Report received by SET_REPORT request. Warning: Called in ISR context
 * First byte of data will be the report ID
 *
 * @param report Data and length received
 */
 virtual void HID_callbackSetReport(HID_REPORT *report){};


 /*
 * Called by USBDevice on Endpoint0 request. Warning: Called in ISR context
 * This is used to handle extensions to standard requests
 * and class specific requests
 *
 * @returns true if class handles this request
 */
 virtual bool USBCallback_request();


 /*
 * Called by USBDevice layer. Set configuration of the device.
 * For instance, you can add all endpoints that you need on this function.
 *
 * @param configuration Number of the configuration
 * @returns true if class handles this request
 */
 virtual bool USBCallback_setConfiguration(uint8_t configuration);

 private:
 HID_REPORT outputReport;
 uint8_t output_length;
 uint8_t input_length;
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID_Types.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBHID_Types.h
@@ -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
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.cpp
@@ -0,0 +1,553 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"

 #include "USBKeyboard.h"

 #define REPORT_ID_KEYBOARD 1
 #define REPORT_ID_VOLUME 3


 typedef struct {
 unsigned char usage;
 unsigned char modifier;
 } KEYMAP;

 #ifdef US_KEYBOARD
 /* US keyboard (as HID standard) */
 #define KEYMAP_SIZE (152)
 const KEYMAP keymap[KEYMAP_SIZE] = {
 {0, 0}, /* NUL */
 {0, 0}, /* SOH */
 {0, 0}, /* STX */
 {0, 0}, /* ETX */
 {0, 0}, /* EOT */
 {0, 0}, /* ENQ */
 {0, 0}, /* ACK */
 {0, 0}, /* BEL */
 {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */
 {0x2b, 0}, /* TAB */ /* Keyboard Tab */
 {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */
 {0, 0}, /* VT */
 {0, 0}, /* FF */
 {0, 0}, /* CR */
 {0, 0}, /* SO */
 {0, 0}, /* SI */
 {0, 0}, /* DEL */
 {0, 0}, /* DC1 */
 {0, 0}, /* DC2 */
 {0, 0}, /* DC3 */
 {0, 0}, /* DC4 */
 {0, 0}, /* NAK */
 {0, 0}, /* SYN */
 {0, 0}, /* ETB */
 {0, 0}, /* CAN */
 {0, 0}, /* EM */
 {0, 0}, /* SUB */
 {0, 0}, /* ESC */
 {0, 0}, /* FS */
 {0, 0}, /* GS */
 {0, 0}, /* RS */
 {0, 0}, /* US */
 {0x2c, 0}, /* */
 {0x1e, KEY_SHIFT}, /* ! */
 {0x34, KEY_SHIFT}, /* " */
 {0x20, KEY_SHIFT}, /* # */
 {0x21, KEY_SHIFT}, /* $ */
 {0x22, KEY_SHIFT}, /* % */
 {0x24, KEY_SHIFT}, /* & */
 {0x34, 0}, /* ' */
 {0x26, KEY_SHIFT}, /* ( */
 {0x27, KEY_SHIFT}, /* ) */
 {0x25, KEY_SHIFT}, /* * */
 {0x2e, KEY_SHIFT}, /* + */
 {0x36, 0}, /* , */
 {0x2d, 0}, /* - */
 {0x37, 0}, /* . */
 {0x38, 0}, /* / */
 {0x27, 0}, /* 0 */
 {0x1e, 0}, /* 1 */
 {0x1f, 0}, /* 2 */
 {0x20, 0}, /* 3 */
 {0x21, 0}, /* 4 */
 {0x22, 0}, /* 5 */
 {0x23, 0}, /* 6 */
 {0x24, 0}, /* 7 */
 {0x25, 0}, /* 8 */
 {0x26, 0}, /* 9 */
 {0x33, KEY_SHIFT}, /* : */
 {0x33, 0}, /* ; */
 {0x36, KEY_SHIFT}, /* < */
 {0x2e, 0}, /* = */
 {0x37, KEY_SHIFT}, /* > */
 {0x38, KEY_SHIFT}, /* ? */
 {0x1f, KEY_SHIFT}, /* @ */
 {0x04, KEY_SHIFT}, /* A */
 {0x05, KEY_SHIFT}, /* B */
 {0x06, KEY_SHIFT}, /* C */
 {0x07, KEY_SHIFT}, /* D */
 {0x08, KEY_SHIFT}, /* E */
 {0x09, KEY_SHIFT}, /* F */
 {0x0a, KEY_SHIFT}, /* G */
 {0x0b, KEY_SHIFT}, /* H */
 {0x0c, KEY_SHIFT}, /* I */
 {0x0d, KEY_SHIFT}, /* J */
 {0x0e, KEY_SHIFT}, /* K */
 {0x0f, KEY_SHIFT}, /* L */
 {0x10, KEY_SHIFT}, /* M */
 {0x11, KEY_SHIFT}, /* N */
 {0x12, KEY_SHIFT}, /* O */
 {0x13, KEY_SHIFT}, /* P */
 {0x14, KEY_SHIFT}, /* Q */
 {0x15, KEY_SHIFT}, /* R */
 {0x16, KEY_SHIFT}, /* S */
 {0x17, KEY_SHIFT}, /* T */
 {0x18, KEY_SHIFT}, /* U */
 {0x19, KEY_SHIFT}, /* V */
 {0x1a, KEY_SHIFT}, /* W */
 {0x1b, KEY_SHIFT}, /* X */
 {0x1c, KEY_SHIFT}, /* Y */
 {0x1d, KEY_SHIFT}, /* Z */
 {0x2f, 0}, /* [ */
 {0x31, 0}, /* \ */
 {0x30, 0}, /* ] */
 {0x23, KEY_SHIFT}, /* ^ */
 {0x2d, KEY_SHIFT}, /* _ */
 {0x35, 0}, /* ` */
 {0x04, 0}, /* a */
 {0x05, 0}, /* b */
 {0x06, 0}, /* c */
 {0x07, 0}, /* d */
 {0x08, 0}, /* e */
 {0x09, 0}, /* f */
 {0x0a, 0}, /* g */
 {0x0b, 0}, /* h */
 {0x0c, 0}, /* i */
 {0x0d, 0}, /* j */
 {0x0e, 0}, /* k */
 {0x0f, 0}, /* l */
 {0x10, 0}, /* m */
 {0x11, 0}, /* n */
 {0x12, 0}, /* o */
 {0x13, 0}, /* p */
 {0x14, 0}, /* q */
 {0x15, 0}, /* r */
 {0x16, 0}, /* s */
 {0x17, 0}, /* t */
 {0x18, 0}, /* u */
 {0x19, 0}, /* v */
 {0x1a, 0}, /* w */
 {0x1b, 0}, /* x */
 {0x1c, 0}, /* y */
 {0x1d, 0}, /* z */
 {0x2f, KEY_SHIFT}, /* { */
 {0x31, KEY_SHIFT}, /* | */
 {0x30, KEY_SHIFT}, /* } */
 {0x35, KEY_SHIFT}, /* ~ */
 {0,0}, /* DEL */

 {0x3a, 0}, /* F1 */
 {0x3b, 0}, /* F2 */
 {0x3c, 0}, /* F3 */
 {0x3d, 0}, /* F4 */
 {0x3e, 0}, /* F5 */
 {0x3f, 0}, /* F6 */
 {0x40, 0}, /* F7 */
 {0x41, 0}, /* F8 */
 {0x42, 0}, /* F9 */
 {0x43, 0}, /* F10 */
 {0x44, 0}, /* F11 */
 {0x45, 0}, /* F12 */

 {0x46, 0}, /* PRINT_SCREEN */
 {0x47, 0}, /* SCROLL_LOCK */
 {0x39, 0}, /* CAPS_LOCK */
 {0x53, 0}, /* NUM_LOCK */
 {0x49, 0}, /* INSERT */
 {0x4a, 0}, /* HOME */
 {0x4b, 0}, /* PAGE_UP */
 {0x4e, 0}, /* PAGE_DOWN */

 {0x4f, 0}, /* RIGHT_ARROW */
 {0x50, 0}, /* LEFT_ARROW */
 {0x51, 0}, /* DOWN_ARROW */
 {0x52, 0}, /* UP_ARROW */
 };

 #else
 /* UK keyboard */
 #define KEYMAP_SIZE (152)
 const KEYMAP keymap[KEYMAP_SIZE] = {
 {0, 0}, /* NUL */
 {0, 0}, /* SOH */
 {0, 0}, /* STX */
 {0, 0}, /* ETX */
 {0, 0}, /* EOT */
 {0, 0}, /* ENQ */
 {0, 0}, /* ACK */
 {0, 0}, /* BEL */
 {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */
 {0x2b, 0}, /* TAB */ /* Keyboard Tab */
 {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */
 {0, 0}, /* VT */
 {0, 0}, /* FF */
 {0, 0}, /* CR */
 {0, 0}, /* SO */
 {0, 0}, /* SI */
 {0, 0}, /* DEL */
 {0, 0}, /* DC1 */
 {0, 0}, /* DC2 */
 {0, 0}, /* DC3 */
 {0, 0}, /* DC4 */
 {0, 0}, /* NAK */
 {0, 0}, /* SYN */
 {0, 0}, /* ETB */
 {0, 0}, /* CAN */
 {0, 0}, /* EM */
 {0, 0}, /* SUB */
 {0, 0}, /* ESC */
 {0, 0}, /* FS */
 {0, 0}, /* GS */
 {0, 0}, /* RS */
 {0, 0}, /* US */
 {0x2c, 0}, /* */
 {0x1e, KEY_SHIFT}, /* ! */
 {0x1f, KEY_SHIFT}, /* " */
 {0x32, 0}, /* # */
 {0x21, KEY_SHIFT}, /* $ */
 {0x22, KEY_SHIFT}, /* % */
 {0x24, KEY_SHIFT}, /* & */
 {0x34, 0}, /* ' */
 {0x26, KEY_SHIFT}, /* ( */
 {0x27, KEY_SHIFT}, /* ) */
 {0x25, KEY_SHIFT}, /* * */
 {0x2e, KEY_SHIFT}, /* + */
 {0x36, 0}, /* , */
 {0x2d, 0}, /* - */
 {0x37, 0}, /* . */
 {0x38, 0}, /* / */
 {0x27, 0}, /* 0 */
 {0x1e, 0}, /* 1 */
 {0x1f, 0}, /* 2 */
 {0x20, 0}, /* 3 */
 {0x21, 0}, /* 4 */
 {0x22, 0}, /* 5 */
 {0x23, 0}, /* 6 */
 {0x24, 0}, /* 7 */
 {0x25, 0}, /* 8 */
 {0x26, 0}, /* 9 */
 {0x33, KEY_SHIFT}, /* : */
 {0x33, 0}, /* ; */
 {0x36, KEY_SHIFT}, /* < */
 {0x2e, 0}, /* = */
 {0x37, KEY_SHIFT}, /* > */
 {0x38, KEY_SHIFT}, /* ? */
 {0x34, KEY_SHIFT}, /* @ */
 {0x04, KEY_SHIFT}, /* A */
 {0x05, KEY_SHIFT}, /* B */
 {0x06, KEY_SHIFT}, /* C */
 {0x07, KEY_SHIFT}, /* D */
 {0x08, KEY_SHIFT}, /* E */
 {0x09, KEY_SHIFT}, /* F */
 {0x0a, KEY_SHIFT}, /* G */
 {0x0b, KEY_SHIFT}, /* H */
 {0x0c, KEY_SHIFT}, /* I */
 {0x0d, KEY_SHIFT}, /* J */
 {0x0e, KEY_SHIFT}, /* K */
 {0x0f, KEY_SHIFT}, /* L */
 {0x10, KEY_SHIFT}, /* M */
 {0x11, KEY_SHIFT}, /* N */
 {0x12, KEY_SHIFT}, /* O */
 {0x13, KEY_SHIFT}, /* P */
 {0x14, KEY_SHIFT}, /* Q */
 {0x15, KEY_SHIFT}, /* R */
 {0x16, KEY_SHIFT}, /* S */
 {0x17, KEY_SHIFT}, /* T */
 {0x18, KEY_SHIFT}, /* U */
 {0x19, KEY_SHIFT}, /* V */
 {0x1a, KEY_SHIFT}, /* W */
 {0x1b, KEY_SHIFT}, /* X */
 {0x1c, KEY_SHIFT}, /* Y */
 {0x1d, KEY_SHIFT}, /* Z */
 {0x2f, 0}, /* [ */
 {0x64, 0}, /* \ */
 {0x30, 0}, /* ] */
 {0x23, KEY_SHIFT}, /* ^ */
 {0x2d, KEY_SHIFT}, /* _ */
 {0x35, 0}, /* ` */
 {0x04, 0}, /* a */
 {0x05, 0}, /* b */
 {0x06, 0}, /* c */
 {0x07, 0}, /* d */
 {0x08, 0}, /* e */
 {0x09, 0}, /* f */
 {0x0a, 0}, /* g */
 {0x0b, 0}, /* h */
 {0x0c, 0}, /* i */
 {0x0d, 0}, /* j */
 {0x0e, 0}, /* k */
 {0x0f, 0}, /* l */
 {0x10, 0}, /* m */
 {0x11, 0}, /* n */
 {0x12, 0}, /* o */
 {0x13, 0}, /* p */
 {0x14, 0}, /* q */
 {0x15, 0}, /* r */
 {0x16, 0}, /* s */
 {0x17, 0}, /* t */
 {0x18, 0}, /* u */
 {0x19, 0}, /* v */
 {0x1a, 0}, /* w */
 {0x1b, 0}, /* x */
 {0x1c, 0}, /* y */
 {0x1d, 0}, /* z */
 {0x2f, KEY_SHIFT}, /* { */
 {0x64, KEY_SHIFT}, /* | */
 {0x30, KEY_SHIFT}, /* } */
 {0x32, KEY_SHIFT}, /* ~ */
 {0,0}, /* DEL */

 {0x3a, 0}, /* F1 */
 {0x3b, 0}, /* F2 */
 {0x3c, 0}, /* F3 */
 {0x3d, 0}, /* F4 */
 {0x3e, 0}, /* F5 */
 {0x3f, 0}, /* F6 */
 {0x40, 0}, /* F7 */
 {0x41, 0}, /* F8 */
 {0x42, 0}, /* F9 */
 {0x43, 0}, /* F10 */
 {0x44, 0}, /* F11 */
 {0x45, 0}, /* F12 */

 {0x46, 0}, /* PRINT_SCREEN */
 {0x47, 0}, /* SCROLL_LOCK */
 {0x39, 0}, /* CAPS_LOCK */
 {0x53, 0}, /* NUM_LOCK */
 {0x49, 0}, /* INSERT */
 {0x4a, 0}, /* HOME */
 {0x4b, 0}, /* PAGE_UP */
 {0x4e, 0}, /* PAGE_DOWN */

 {0x4f, 0}, /* RIGHT_ARROW */
 {0x50, 0}, /* LEFT_ARROW */
 {0x51, 0}, /* DOWN_ARROW */
 {0x52, 0}, /* UP_ARROW */
 };
 #endif

 uint8_t * USBKeyboard::reportDesc() {
 static uint8_t reportDescriptor[] = {
 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x06, // Keyboard
 COLLECTION(1), 0x01, // Application
 REPORT_ID(1), REPORT_ID_KEYBOARD,

 USAGE_PAGE(1), 0x07, // Key Codes
 USAGE_MINIMUM(1), 0xE0,
 USAGE_MAXIMUM(1), 0xE7,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 REPORT_SIZE(1), 0x01,
 REPORT_COUNT(1), 0x08,
 INPUT(1), 0x02, // Data, Variable, Absolute
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x08,
 INPUT(1), 0x01, // Constant


 REPORT_COUNT(1), 0x05,
 REPORT_SIZE(1), 0x01,
 USAGE_PAGE(1), 0x08, // LEDs
 USAGE_MINIMUM(1), 0x01,
 USAGE_MAXIMUM(1), 0x05,
 OUTPUT(1), 0x02, // Data, Variable, Absolute
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x03,
 OUTPUT(1), 0x01, // Constant


 REPORT_COUNT(1), 0x06,
 REPORT_SIZE(1), 0x08,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x65,
 USAGE_PAGE(1), 0x07, // Key Codes
 USAGE_MINIMUM(1), 0x00,
 USAGE_MAXIMUM(1), 0x65,
 INPUT(1), 0x00, // Data, Array
 END_COLLECTION(0),

 // Media Control
 USAGE_PAGE(1), 0x0C,
 USAGE(1), 0x01,
 COLLECTION(1), 0x01,
 REPORT_ID(1), REPORT_ID_VOLUME,
 USAGE_PAGE(1), 0x0C,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 REPORT_SIZE(1), 0x01,
 REPORT_COUNT(1), 0x07,
 USAGE(1), 0xB5, // Next Track
 USAGE(1), 0xB6, // Previous Track
 USAGE(1), 0xB7, // Stop
 USAGE(1), 0xCD, // Play / Pause
 USAGE(1), 0xE2, // Mute
 USAGE(1), 0xE9, // Volume Up
 USAGE(1), 0xEA, // Volume Down
 INPUT(1), 0x02, // Input (Data, Variable, Absolute)
 REPORT_COUNT(1), 0x01,
 INPUT(1), 0x01,
 END_COLLECTION(0),
 };
 reportLength = sizeof(reportDescriptor);
 return reportDescriptor;
 }


 bool USBKeyboard::EPINT_OUT_callback() {
 uint32_t bytesRead = 0;
 uint8_t led[65];
 USBDevice::readEP(EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE);

 // we take led[1] because led[0] is the report ID
 lock_status = led[1] & 0x07;

 // We activate the endpoint to be able to recceive data
 if (!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
 return false;
 return true;
 }

 uint8_t USBKeyboard::lockStatus() {
 return lock_status;
 }

 int USBKeyboard::_putc(int c) {
 return keyCode(c, keymap[c].modifier);
 }

 bool USBKeyboard::keyCode(uint8_t key, uint8_t modifier) {
 // Send a simulated keyboard keypress. Returns true if successful.
 HID_REPORT report;

 report.data[0] = REPORT_ID_KEYBOARD;
 report.data[1] = modifier;
 report.data[2] = 0;
 report.data[3] = keymap[key].usage;
 report.data[4] = 0;
 report.data[5] = 0;
 report.data[6] = 0;
 report.data[7] = 0;
 report.data[8] = 0;

 report.length = 9;

 if (!send(&report)) {
 return false;
 }

 report.data[1] = 0;
 report.data[3] = 0;

 if (!send(&report)) {
 return false;
 }

 return true;

 }


 bool USBKeyboard::mediaControl(MEDIA_KEY key) {
 HID_REPORT report;

 report.data[0] = REPORT_ID_VOLUME;
 report.data[1] = (1 << key) & 0x7f;

 report.length = 2;

 if (!send(&report)) {
 return false;
 }

 report.data[0] = REPORT_ID_VOLUME;
 report.data[1] = 0;

 report.length = 2;

 return send(&report);
 }


 #define DEFAULT_CONFIGURATION (1)
 #define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \
 + (1 * INTERFACE_DESCRIPTOR_LENGTH) \
 + (1 * HID_DESCRIPTOR_LENGTH) \
 + (2 * ENDPOINT_DESCRIPTOR_LENGTH))

 uint8_t * USBKeyboard::configurationDesc() {
 static uint8_t configurationDescriptor[] = {
 CONFIGURATION_DESCRIPTOR_LENGTH,// bLength
 CONFIGURATION_DESCRIPTOR, // bDescriptorType
 LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB)
 MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB)
 0x01, // bNumInterfaces
 DEFAULT_CONFIGURATION, // bConfigurationValue
 0x00, // iConfiguration
 C_RESERVED | C_SELF_POWERED, // bmAttributes
 C_POWER(0), // bMaxPowerHello World from Mbed

 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x00, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x02, // bNumEndpoints
 HID_CLASS, // bInterfaceClass
 1, // bInterfaceSubClass
 1, // bInterfaceProtocol (keyboard)
 0x00, // iInterface

 HID_DESCRIPTOR_LENGTH, // bLength
 HID_DESCRIPTOR, // bDescriptorType
 LSB(HID_VERSION_1_11), // bcdHID (LSB)
 MSB(HID_VERSION_1_11), // bcdHID (MSB)
 0x00, // bCountryCode
 0x01, // bNumDescriptors
 REPORT_DESCRIPTOR, // bDescriptorType
 (uint8_t)(LSB(reportDescLength())), // wDescriptorLength (LSB)
 (uint8_t)(MSB(reportDescLength())), // wDescriptorLength (MSB)

 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_IN), // bEndpointAddress
 E_INTERRUPT, // bmAttributes
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 1, // bInterval (milliseconds)

 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_OUT), // bEndpointAddress
 E_INTERRUPT, // bmAttributes
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 1, // bInterval (milliseconds)
 };
 return configurationDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBKeyboard.h
@@ -0,0 +1,183 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBKEYBOARD_H
 #define USBKEYBOARD_H

 #include "USBHID.h"
 #include "Stream.h"

 /* Modifiers */
 enum MODIFIER_KEY {
 KEY_CTRL = 1,
 KEY_SHIFT = 2,
 KEY_ALT = 4,
 };


 enum MEDIA_KEY {
 KEY_NEXT_TRACK, /*!< next Track Button */
 KEY_PREVIOUS_TRACK, /*!< Previous track Button */
 KEY_STOP, /*!< Stop Button */
 KEY_PLAY_PAUSE, /*!< Play/Pause Button */
 KEY_MUTE, /*!< Mute Button */
 KEY_VOLUME_UP, /*!< Volume Up Button */
 KEY_VOLUME_DOWN, /*!< Volume Down Button */
 };

 enum FUNCTION_KEY {
 KEY_F1 = 128, /* F1 key */
 KEY_F2, /* F2 key */
 KEY_F3, /* F3 key */
 KEY_F4, /* F4 key */
 KEY_F5, /* F5 key */
 KEY_F6, /* F6 key */
 KEY_F7, /* F7 key */
 KEY_F8, /* F8 key */
 KEY_F9, /* F9 key */
 KEY_F10, /* F10 key */
 KEY_F11, /* F11 key */
 KEY_F12, /* F12 key */

 KEY_PRINT_SCREEN, /* Print Screen key */
 KEY_SCROLL_LOCK, /* Scroll lock */
 KEY_CAPS_LOCK, /* caps lock */
 KEY_NUM_LOCK, /* num lock */
 KEY_INSERT, /* Insert key */
 KEY_HOME, /* Home key */
 KEY_PAGE_UP, /* Page Up key */
 KEY_PAGE_DOWN, /* Page Down key */

 RIGHT_ARROW, /* Right arrow */
 LEFT_ARROW, /* Left arrow */
 DOWN_ARROW, /* Down arrow */
 UP_ARROW, /* Up arrow */
 };

 /**
 * USBKeyboard example
 * @code
 *
 * #include "mbed.h"
 * #include "USBKeyboard.h"
 *
 * USBKeyboard key;
 *
 * int main(void)
 * {
 * while (1)
 * {
 * key.printf("Hello World\r\n");
 * wait(1);
 * }
 * }
 *
 * @endcode
 */
 class USBKeyboard: public USBHID, public Stream {
 public:

 /**
 * Constructor
 *
 *
 * @param leds Leds bus: first: NUM_LOCK, second: CAPS_LOCK, third: SCROLL_LOCK
 * @param vendor_id Your vendor_id (default: 0x1235)
 * @param product_id Your product_id (default: 0x0050)
 * @param product_release Your preoduct_release (default: 0x0001)
 *
 */
 USBKeyboard(uint16_t vendor_id = 0x1235, uint16_t product_id = 0x0050, uint16_t product_release = 0x0001):
 USBHID(0, 0, vendor_id, product_id, product_release, false) {
 lock_status = 0;
 connect();
 };

 /**
 * To send a character defined by a modifier(CTRL, SHIFT, ALT) and the key
 *
 * @code
 * //To send CTRL + s (save)
 * keyboard.keyCode('s', KEY_CTRL);
 * @endcode
 *
 * @param modifier bit 0: KEY_CTRL, bit 1: KEY_SHIFT, bit 2: KEY_ALT (default: 0)
 * @param key character to send
 * @returns true if there is no error, false otherwise
 */
 bool keyCode(uint8_t key, uint8_t modifier = 0);

 /**
 * Send a character
 *
 * @param c character to be sent
 * @returns true if there is no error, false otherwise
 */
 virtual int _putc(int c);

 /**
 * Control media keys
 *
 * @param key media key pressed (KEY_NEXT_TRACK, KEY_PREVIOUS_TRACK, KEY_STOP, KEY_PLAY_PAUSE, KEY_MUTE, KEY_VOLUME_UP, KEY_VOLUME_DOWN)
 * @returns true if there is no error, false otherwise
 */
 bool mediaControl(MEDIA_KEY key);

 /*
 * To define the report descriptor. Warning: this method has to store the length of the report descriptor in reportLength.
 *
 * @returns pointer to the report descriptor
 */
 virtual uint8_t * reportDesc();

 /*
 * Called when a data is received on the OUT endpoint. Useful to switch on LED of LOCK keys
 *
 * @returns if handle by subclass, return true
 */
 virtual bool EPINT_OUT_callback();

 /**
 * Read status of lock keys. Useful to switch-on/off leds according to key pressed. Only the first three bits of the result is important:
 * - First bit: NUM_LOCK
 * - Second bit: CAPS_LOCK
 * - Third bit: SCROLL_LOCK
 *
 * @returns status of lock keys
 */
 uint8_t lockStatus();

 protected:
 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();

 private:
 //dummy otherwise it doesn,t compile (we must define all methods of an abstract class)
 virtual int _getc() {
 return -1;
 };

 uint8_t lock_status;

 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.cpp
@@ -0,0 +1,245 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBMouse.h"

 bool USBMouse::update(int16_t x, int16_t y, uint8_t button, int8_t z) {
 switch (mouse_type) {
 case REL_MOUSE:
 while (x > 127) {
 if (!mouseSend(127, 0, button, z)) return false;
 x = x - 127;
 }
 while (x < -128) {
 if (!mouseSend(-128, 0, button, z)) return false;
 x = x + 128;
 }
 while (y > 127) {
 if (!mouseSend(0, 127, button, z)) return false;
 y = y - 127;
 }
 while (y < -128) {
 if (!mouseSend(0, -128, button, z)) return false;
 y = y + 128;
 }
 return mouseSend(x, y, button, z);
 case ABS_MOUSE:
 HID_REPORT report;

 report.data[0] = x & 0xff;
 report.data[1] = (x >> 8) & 0xff;
 report.data[2] = y & 0xff;
 report.data[3] = (y >> 8) & 0xff;
 report.data[4] = -z;
 report.data[5] = button & 0x07;

 report.length = 6;

 return send(&report);
 default:
 return false;
 }
 }

 bool USBMouse::mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z) {
 HID_REPORT report;
 report.data[0] = buttons & 0x07;
 report.data[1] = x;
 report.data[2] = y;
 report.data[3] = -z; // >0 to scroll down, <0 to scroll up

 report.length = 4;

 return send(&report);
 }

 bool USBMouse::move(int16_t x, int16_t y) {
 return update(x, y, button, 0);
 }

 bool USBMouse::scroll(int8_t z) {
 return update(0, 0, button, z);
 }


 bool USBMouse::doubleClick() {
 if (!click(MOUSE_LEFT))
 return false;
 wait(0.1);
 return click(MOUSE_LEFT);
 }

 bool USBMouse::click(uint8_t button) {
 if (!update(0, 0, button, 0))
 return false;
 wait(0.01);
 return update(0, 0, 0, 0);
 }

 bool USBMouse::press(uint8_t button_) {
 button = button_ & 0x07;
 return update(0, 0, button, 0);
 }

 bool USBMouse::release(uint8_t button_) {
 button = (button & (~button_)) & 0x07;
 return update(0, 0, button, 0);
 }


 uint8_t * USBMouse::reportDesc() {

 if (mouse_type == REL_MOUSE) {
 static uint8_t reportDescriptor[] = {
 USAGE_PAGE(1), 0x01, // Genric Desktop
 USAGE(1), 0x02, // Mouse
 COLLECTION(1), 0x01, // Application
 USAGE(1), 0x01, // Pointer
 COLLECTION(1), 0x00, // Physical

 REPORT_COUNT(1), 0x03,
 REPORT_SIZE(1), 0x01,
 USAGE_PAGE(1), 0x09, // Buttons
 USAGE_MINIMUM(1), 0x1,
 USAGE_MAXIMUM(1), 0x3,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 INPUT(1), 0x02,
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x05,
 INPUT(1), 0x01,

 REPORT_COUNT(1), 0x03,
 REPORT_SIZE(1), 0x08,
 USAGE_PAGE(1), 0x01,
 USAGE(1), 0x30, // X
 USAGE(1), 0x31, // Y
 USAGE(1), 0x38, // scroll
 LOGICAL_MINIMUM(1), 0x81,
 LOGICAL_MAXIMUM(1), 0x7f,
 INPUT(1), 0x06, // Relative data

 END_COLLECTION(0),
 END_COLLECTION(0),
 };
 reportLength = sizeof(reportDescriptor);
 return reportDescriptor;
 } else if (mouse_type == ABS_MOUSE) {
 static uint8_t reportDescriptor[] = {

 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x02, // Mouse
 COLLECTION(1), 0x01, // Application
 USAGE(1), 0x01, // Pointer
 COLLECTION(1), 0x00, // Physical

 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x30, // X
 USAGE(1), 0x31, // Y
 LOGICAL_MINIMUM(1), 0x00, // 0
 LOGICAL_MAXIMUM(2), 0xff, 0x7f, // 32767
 REPORT_SIZE(1), 0x10,
 REPORT_COUNT(1), 0x02,
 INPUT(1), 0x02, // Data, Variable, Absolute

 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x38, // scroll
 LOGICAL_MINIMUM(1), 0x81, // -127
 LOGICAL_MAXIMUM(1), 0x7f, // 127
 REPORT_SIZE(1), 0x08,
 REPORT_COUNT(1), 0x01,
 INPUT(1), 0x06, // Data, Variable, Relative

 USAGE_PAGE(1), 0x09, // Buttons
 USAGE_MINIMUM(1), 0x01,
 USAGE_MAXIMUM(1), 0x03,
 LOGICAL_MINIMUM(1), 0x00, // 0
 LOGICAL_MAXIMUM(1), 0x01, // 1
 REPORT_COUNT(1), 0x03,
 REPORT_SIZE(1), 0x01,
 INPUT(1), 0x02, // Data, Variable, Absolute
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x05,
 INPUT(1), 0x01, // Constant

 END_COLLECTION(0),
 END_COLLECTION(0)
 };
 reportLength = sizeof(reportDescriptor);
 return reportDescriptor;
 }
 return NULL;
 }

 #define DEFAULT_CONFIGURATION (1)
 #define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) \
 + (1 * INTERFACE_DESCRIPTOR_LENGTH) \
 + (1 * HID_DESCRIPTOR_LENGTH) \
 + (2 * ENDPOINT_DESCRIPTOR_LENGTH))

 uint8_t * USBMouse::configurationDesc() {
 static uint8_t configurationDescriptor[] = {
 CONFIGURATION_DESCRIPTOR_LENGTH,// bLength
 CONFIGURATION_DESCRIPTOR, // bDescriptorType
 LSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (LSB)
 MSB(TOTAL_DESCRIPTOR_LENGTH), // wTotalLength (MSB)
 0x01, // bNumInterfaces
 DEFAULT_CONFIGURATION, // bConfigurationValue
 0x00, // iConfiguration
 C_RESERVED | C_SELF_POWERED, // bmAttributes
 C_POWER(0), // bMaxPowerHello World from Mbed

 INTERFACE_DESCRIPTOR_LENGTH, // bLength
 INTERFACE_DESCRIPTOR, // bDescriptorType
 0x00, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x02, // bNumEndpoints
 HID_CLASS, // bInterfaceClass
 1, // bInterfaceSubClass
 2, // bInterfaceProtocol (mouse)
 0x00, // iInterface

 HID_DESCRIPTOR_LENGTH, // bLength
 HID_DESCRIPTOR, // bDescriptorType
 LSB(HID_VERSION_1_11), // bcdHID (LSB)
 MSB(HID_VERSION_1_11), // bcdHID (MSB)
 0x00, // bCountryCode
 0x01, // bNumDescriptors
 REPORT_DESCRIPTOR, // bDescriptorType
 (uint8_t)(LSB(reportDescLength())), // wDescriptorLength (LSB)
 (uint8_t)(MSB(reportDescLength())), // wDescriptorLength (MSB)

 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_IN), // bEndpointAddress
 E_INTERRUPT, // bmAttributes
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 1, // bInterval (milliseconds)

 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_OUT), // bEndpointAddress
 E_INTERRUPT, // bmAttributes
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 1, // bInterval (milliseconds)
 };
 return configurationDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouse.h
@@ -0,0 +1,209 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBMOUSE_H
 #define USBMOUSE_H

 #include "USBHID.h"

 #define REPORT_ID_MOUSE 2

 /* Common usage */

 enum MOUSE_BUTTON
 {
 MOUSE_LEFT = 1,
 MOUSE_RIGHT = 2,
 MOUSE_MIDDLE = 4,
 };

 /* X and Y limits */
 /* These values do not directly map to screen pixels */
 /* Zero may be interpreted as meaning 'no movement' */
 #define X_MIN_ABS (1) /*!< Minimum value on x-axis */
 #define Y_MIN_ABS (1) /*!< Minimum value on y-axis */
 #define X_MAX_ABS (0x7fff) /*!< Maximum value on x-axis */
 #define Y_MAX_ABS (0x7fff) /*!< Maximum value on y-axis */

 #define X_MIN_REL (-127) /*!< The maximum value that we can move to the left on the x-axis */
 #define Y_MIN_REL (-127) /*!< The maximum value that we can move up on the y-axis */
 #define X_MAX_REL (127) /*!< The maximum value that we can move to the right on the x-axis */
 #define Y_MAX_REL (127) /*!< The maximum value that we can move down on the y-axis */

 enum MOUSE_TYPE
 {
 ABS_MOUSE,
 REL_MOUSE,
 };

 /**
 *
 * USBMouse example
 * @code
 * #include "mbed.h"
 * #include "USBMouse.h"
 *
 * USBMouse mouse;
 *
 * int main(void)
 * {
 * while (1)
 * {
 * mouse.move(20, 0);
 * wait(0.5);
 * }
 * }
 *
 * @endcode
 *
 *
 * @code
 * #include "mbed.h"
 * #include "USBMouse.h"
 * #include <math.h>
 *
 * USBMouse mouse(ABS_MOUSE);
 *
 * int main(void)
 * {
 * uint16_t x_center = (X_MAX_ABS - X_MIN_ABS)/2;
 * uint16_t y_center = (Y_MAX_ABS - Y_MIN_ABS)/2;
 * uint16_t x_screen = 0;
 * uint16_t y_screen = 0;
 *
 * uint32_t x_origin = x_center;
 * uint32_t y_origin = y_center;
 * uint32_t radius = 5000;
 * uint32_t angle = 0;
 *
 * while (1)
 * {
 * x_screen = x_origin + cos((double)angle*3.14/180.0)*radius;
 * y_screen = y_origin + sin((double)angle*3.14/180.0)*radius;
 *
 * mouse.move(x_screen, y_screen);
 * angle += 3;
 * wait(0.01);
 * }
 * }
 *
 * @endcode
 */
 class USBMouse: public USBHID
 {
 public:

 /**
 * Constructor
 *
 * @param mouse_type Mouse type: ABS_MOUSE (absolute mouse) or REL_MOUSE (relative mouse) (default: REL_MOUSE)
 * @param vendor_id Your vendor_id (default: 0x1234)
 * @param product_id Your product_id (default: 0x0001)
 * @param product_release Your preoduct_release (default: 0x0001)
 *
 */
 USBMouse(MOUSE_TYPE mouse_type = REL_MOUSE, uint16_t vendor_id = 0x1234, uint16_t product_id = 0x0001, uint16_t product_release = 0x0001):
 USBHID(0, 0, vendor_id, product_id, product_release, false)
 {
 button = 0;
 this->mouse_type = mouse_type;
 connect();
 };

 /**
 * Write a state of the mouse
 *
 * @param x x-axis position
 * @param y y-axis position
 * @param buttons buttons state (first bit represents MOUSE_LEFT, second bit MOUSE_RIGHT and third bit MOUSE_MIDDLE)
 * @param z wheel state (>0 to scroll down, <0 to scroll up)
 * @returns true if there is no error, false otherwise
 */
 bool update(int16_t x, int16_t y, uint8_t buttons, int8_t z);


 /**
 * Move the cursor to (x, y)
 *
 * @param x-axis position
 * @param y-axis position
 * @returns true if there is no error, false otherwise
 */
 bool move(int16_t x, int16_t y);

 /**
 * Press one or several buttons
 *
 * @param button button state (ex: press(MOUSE_LEFT))
 * @returns true if there is no error, false otherwise
 */
 bool press(uint8_t button);

 /**
 * Release one or several buttons
 *
 * @param button button state (ex: release(MOUSE_LEFT))
 * @returns true if there is no error, false otherwise
 */
 bool release(uint8_t button);

 /**
 * Double click (MOUSE_LEFT)
 *
 * @returns true if there is no error, false otherwise
 */
 bool doubleClick();

 /**
 * Click
 *
 * @param button state of the buttons ( ex: clic(MOUSE_LEFT))
 * @returns true if there is no error, false otherwise
 */
 bool click(uint8_t button);

 /**
 * Scrolling
 *
 * @param z value of the wheel (>0 to go down, <0 to go up)
 * @returns true if there is no error, false otherwise
 */
 bool scroll(int8_t z);

 /*
 * To define the report descriptor. Warning: this method has to store the length of the report descriptor in reportLength.
 *
 * @returns pointer to the report descriptor
 */
 virtual uint8_t * reportDesc();

 protected:
 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();

 private:
 MOUSE_TYPE mouse_type;
 uint8_t button;
 bool mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z);
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.cpp
@@ -0,0 +1,706 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBMouseKeyboard.h"

 typedef struct {
 unsigned char usage;
 unsigned char modifier;
 } KEYMAP;

 #ifdef US_KEYBOARD
 /* US keyboard (as HID standard) */
 #define KEYMAP_SIZE (152)
 const KEYMAP keymap[KEYMAP_SIZE] = {
 {0, 0}, /* NUL */
 {0, 0}, /* SOH */
 {0, 0}, /* STX */
 {0, 0}, /* ETX */
 {0, 0}, /* EOT */
 {0, 0}, /* ENQ */
 {0, 0}, /* ACK */
 {0, 0}, /* BEL */
 {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */
 {0x2b, 0}, /* TAB */ /* Keyboard Tab */
 {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */
 {0, 0}, /* VT */
 {0, 0}, /* FF */
 {0, 0}, /* CR */
 {0, 0}, /* SO */
 {0, 0}, /* SI */
 {0, 0}, /* DEL */
 {0, 0}, /* DC1 */
 {0, 0}, /* DC2 */
 {0, 0}, /* DC3 */
 {0, 0}, /* DC4 */
 {0, 0}, /* NAK */
 {0, 0}, /* SYN */
 {0, 0}, /* ETB */
 {0, 0}, /* CAN */
 {0, 0}, /* EM */
 {0, 0}, /* SUB */
 {0, 0}, /* ESC */
 {0, 0}, /* FS */
 {0, 0}, /* GS */
 {0, 0}, /* RS */
 {0, 0}, /* US */
 {0x2c, 0}, /* */
 {0x1e, KEY_SHIFT}, /* ! */
 {0x34, KEY_SHIFT}, /* " */
 {0x20, KEY_SHIFT}, /* # */
 {0x21, KEY_SHIFT}, /* $ */
 {0x22, KEY_SHIFT}, /* % */
 {0x24, KEY_SHIFT}, /* & */
 {0x34, 0}, /* ' */
 {0x26, KEY_SHIFT}, /* ( */
 {0x27, KEY_SHIFT}, /* ) */
 {0x25, KEY_SHIFT}, /* * */
 {0x2e, KEY_SHIFT}, /* + */
 {0x36, 0}, /* , */
 {0x2d, 0}, /* - */
 {0x37, 0}, /* . */
 {0x38, 0}, /* / */
 {0x27, 0}, /* 0 */
 {0x1e, 0}, /* 1 */
 {0x1f, 0}, /* 2 */
 {0x20, 0}, /* 3 */
 {0x21, 0}, /* 4 */
 {0x22, 0}, /* 5 */
 {0x23, 0}, /* 6 */
 {0x24, 0}, /* 7 */
 {0x25, 0}, /* 8 */
 {0x26, 0}, /* 9 */
 {0x33, KEY_SHIFT}, /* : */
 {0x33, 0}, /* ; */
 {0x36, KEY_SHIFT}, /* < */
 {0x2e, 0}, /* = */
 {0x37, KEY_SHIFT}, /* > */
 {0x38, KEY_SHIFT}, /* ? */
 {0x1f, KEY_SHIFT}, /* @ */
 {0x04, KEY_SHIFT}, /* A */
 {0x05, KEY_SHIFT}, /* B */
 {0x06, KEY_SHIFT}, /* C */
 {0x07, KEY_SHIFT}, /* D */
 {0x08, KEY_SHIFT}, /* E */
 {0x09, KEY_SHIFT}, /* F */
 {0x0a, KEY_SHIFT}, /* G */
 {0x0b, KEY_SHIFT}, /* H */
 {0x0c, KEY_SHIFT}, /* I */
 {0x0d, KEY_SHIFT}, /* J */
 {0x0e, KEY_SHIFT}, /* K */
 {0x0f, KEY_SHIFT}, /* L */
 {0x10, KEY_SHIFT}, /* M */
 {0x11, KEY_SHIFT}, /* N */
 {0x12, KEY_SHIFT}, /* O */
 {0x13, KEY_SHIFT}, /* P */
 {0x14, KEY_SHIFT}, /* Q */
 {0x15, KEY_SHIFT}, /* R */
 {0x16, KEY_SHIFT}, /* S */
 {0x17, KEY_SHIFT}, /* T */
 {0x18, KEY_SHIFT}, /* U */
 {0x19, KEY_SHIFT}, /* V */
 {0x1a, KEY_SHIFT}, /* W */
 {0x1b, KEY_SHIFT}, /* X */
 {0x1c, KEY_SHIFT}, /* Y */
 {0x1d, KEY_SHIFT}, /* Z */
 {0x2f, 0}, /* [ */
 {0x31, 0}, /* \ */
 {0x30, 0}, /* ] */
 {0x23, KEY_SHIFT}, /* ^ */
 {0x2d, KEY_SHIFT}, /* _ */
 {0x35, 0}, /* ` */
 {0x04, 0}, /* a */
 {0x05, 0}, /* b */
 {0x06, 0}, /* c */
 {0x07, 0}, /* d */
 {0x08, 0}, /* e */
 {0x09, 0}, /* f */
 {0x0a, 0}, /* g */
 {0x0b, 0}, /* h */
 {0x0c, 0}, /* i */
 {0x0d, 0}, /* j */
 {0x0e, 0}, /* k */
 {0x0f, 0}, /* l */
 {0x10, 0}, /* m */
 {0x11, 0}, /* n */
 {0x12, 0}, /* o */
 {0x13, 0}, /* p */
 {0x14, 0}, /* q */
 {0x15, 0}, /* r */
 {0x16, 0}, /* s */
 {0x17, 0}, /* t */
 {0x18, 0}, /* u */
 {0x19, 0}, /* v */
 {0x1a, 0}, /* w */
 {0x1b, 0}, /* x */
 {0x1c, 0}, /* y */
 {0x1d, 0}, /* z */
 {0x2f, KEY_SHIFT}, /* { */
 {0x31, KEY_SHIFT}, /* | */
 {0x30, KEY_SHIFT}, /* } */
 {0x35, KEY_SHIFT}, /* ~ */
 {0,0}, /* DEL */

 {0x3a, 0}, /* F1 */
 {0x3b, 0}, /* F2 */
 {0x3c, 0}, /* F3 */
 {0x3d, 0}, /* F4 */
 {0x3e, 0}, /* F5 */
 {0x3f, 0}, /* F6 */
 {0x40, 0}, /* F7 */
 {0x41, 0}, /* F8 */
 {0x42, 0}, /* F9 */
 {0x43, 0}, /* F10 */
 {0x44, 0}, /* F11 */
 {0x45, 0}, /* F12 */

 {0x46, 0}, /* PRINT_SCREEN */
 {0x47, 0}, /* SCROLL_LOCK */
 {0x39, 0}, /* CAPS_LOCK */
 {0x53, 0}, /* NUM_LOCK */
 {0x49, 0}, /* INSERT */
 {0x4a, 0}, /* HOME */
 {0x4b, 0}, /* PAGE_UP */
 {0x4e, 0}, /* PAGE_DOWN */

 {0x4f, 0}, /* RIGHT_ARROW */
 {0x50, 0}, /* LEFT_ARROW */
 {0x51, 0}, /* DOWN_ARROW */
 {0x52, 0}, /* UP_ARROW */
 };

 #else
 /* UK keyboard */
 #define KEYMAP_SIZE (152)
 const KEYMAP keymap[KEYMAP_SIZE] = {
 {0, 0}, /* NUL */
 {0, 0}, /* SOH */
 {0, 0}, /* STX */
 {0, 0}, /* ETX */
 {0, 0}, /* EOT */
 {0, 0}, /* ENQ */
 {0, 0}, /* ACK */
 {0, 0}, /* BEL */
 {0x2a, 0}, /* BS */ /* Keyboard Delete (Backspace) */
 {0x2b, 0}, /* TAB */ /* Keyboard Tab */
 {0x28, 0}, /* LF */ /* Keyboard Return (Enter) */
 {0, 0}, /* VT */
 {0, 0}, /* FF */
 {0, 0}, /* CR */
 {0, 0}, /* SO */
 {0, 0}, /* SI */
 {0, 0}, /* DEL */
 {0, 0}, /* DC1 */
 {0, 0}, /* DC2 */
 {0, 0}, /* DC3 */
 {0, 0}, /* DC4 */
 {0, 0}, /* NAK */
 {0, 0}, /* SYN */
 {0, 0}, /* ETB */
 {0, 0}, /* CAN */
 {0, 0}, /* EM */
 {0, 0}, /* SUB */
 {0, 0}, /* ESC */
 {0, 0}, /* FS */
 {0, 0}, /* GS */
 {0, 0}, /* RS */
 {0, 0}, /* US */
 {0x2c, 0}, /* */
 {0x1e, KEY_SHIFT}, /* ! */
 {0x1f, KEY_SHIFT}, /* " */
 {0x32, 0}, /* # */
 {0x21, KEY_SHIFT}, /* $ */
 {0x22, KEY_SHIFT}, /* % */
 {0x24, KEY_SHIFT}, /* & */
 {0x34, 0}, /* ' */
 {0x26, KEY_SHIFT}, /* ( */
 {0x27, KEY_SHIFT}, /* ) */
 {0x25, KEY_SHIFT}, /* * */
 {0x2e, KEY_SHIFT}, /* + */
 {0x36, 0}, /* , */
 {0x2d, 0}, /* - */
 {0x37, 0}, /* . */
 {0x38, 0}, /* / */
 {0x27, 0}, /* 0 */
 {0x1e, 0}, /* 1 */
 {0x1f, 0}, /* 2 */
 {0x20, 0}, /* 3 */
 {0x21, 0}, /* 4 */
 {0x22, 0}, /* 5 */
 {0x23, 0}, /* 6 */
 {0x24, 0}, /* 7 */
 {0x25, 0}, /* 8 */
 {0x26, 0}, /* 9 */
 {0x33, KEY_SHIFT}, /* : */
 {0x33, 0}, /* ; */
 {0x36, KEY_SHIFT}, /* < */
 {0x2e, 0}, /* = */
 {0x37, KEY_SHIFT}, /* > */
 {0x38, KEY_SHIFT}, /* ? */
 {0x34, KEY_SHIFT}, /* @ */
 {0x04, KEY_SHIFT}, /* A */
 {0x05, KEY_SHIFT}, /* B */
 {0x06, KEY_SHIFT}, /* C */
 {0x07, KEY_SHIFT}, /* D */
 {0x08, KEY_SHIFT}, /* E */
 {0x09, KEY_SHIFT}, /* F */
 {0x0a, KEY_SHIFT}, /* G */
 {0x0b, KEY_SHIFT}, /* H */
 {0x0c, KEY_SHIFT}, /* I */
 {0x0d, KEY_SHIFT}, /* J */
 {0x0e, KEY_SHIFT}, /* K */
 {0x0f, KEY_SHIFT}, /* L */
 {0x10, KEY_SHIFT}, /* M */
 {0x11, KEY_SHIFT}, /* N */
 {0x12, KEY_SHIFT}, /* O */
 {0x13, KEY_SHIFT}, /* P */
 {0x14, KEY_SHIFT}, /* Q */
 {0x15, KEY_SHIFT}, /* R */
 {0x16, KEY_SHIFT}, /* S */
 {0x17, KEY_SHIFT}, /* T */
 {0x18, KEY_SHIFT}, /* U */
 {0x19, KEY_SHIFT}, /* V */
 {0x1a, KEY_SHIFT}, /* W */
 {0x1b, KEY_SHIFT}, /* X */
 {0x1c, KEY_SHIFT}, /* Y */
 {0x1d, KEY_SHIFT}, /* Z */
 {0x2f, 0}, /* [ */
 {0x64, 0}, /* \ */
 {0x30, 0}, /* ] */
 {0x23, KEY_SHIFT}, /* ^ */
 {0x2d, KEY_SHIFT}, /* _ */
 {0x35, 0}, /* ` */
 {0x04, 0}, /* a */
 {0x05, 0}, /* b */
 {0x06, 0}, /* c */
 {0x07, 0}, /* d */
 {0x08, 0}, /* e */
 {0x09, 0}, /* f */
 {0x0a, 0}, /* g */
 {0x0b, 0}, /* h */
 {0x0c, 0}, /* i */
 {0x0d, 0}, /* j */
 {0x0e, 0}, /* k */
 {0x0f, 0}, /* l */
 {0x10, 0}, /* m */
 {0x11, 0}, /* n */
 {0x12, 0}, /* o */
 {0x13, 0}, /* p */
 {0x14, 0}, /* q */
 {0x15, 0}, /* r */
 {0x16, 0}, /* s */
 {0x17, 0}, /* t */
 {0x18, 0}, /* u */
 {0x19, 0}, /* v */
 {0x1a, 0}, /* w */
 {0x1b, 0}, /* x */
 {0x1c, 0}, /* y */
 {0x1d, 0}, /* z */
 {0x2f, KEY_SHIFT}, /* { */
 {0x64, KEY_SHIFT}, /* | */
 {0x30, KEY_SHIFT}, /* } */
 {0x32, KEY_SHIFT}, /* ~ */
 {0,0}, /* DEL */

 {0x3a, 0}, /* F1 */
 {0x3b, 0}, /* F2 */
 {0x3c, 0}, /* F3 */
 {0x3d, 0}, /* F4 */
 {0x3e, 0}, /* F5 */
 {0x3f, 0}, /* F6 */
 {0x40, 0}, /* F7 */
 {0x41, 0}, /* F8 */
 {0x42, 0}, /* F9 */
 {0x43, 0}, /* F10 */
 {0x44, 0}, /* F11 */
 {0x45, 0}, /* F12 */

 {0x46, 0}, /* PRINT_SCREEN */
 {0x47, 0}, /* SCROLL_LOCK */
 {0x39, 0}, /* CAPS_LOCK */
 {0x53, 0}, /* NUM_LOCK */
 {0x49, 0}, /* INSERT */
 {0x4a, 0}, /* HOME */
 {0x4b, 0}, /* PAGE_UP */
 {0x4e, 0}, /* PAGE_DOWN */

 {0x4f, 0}, /* RIGHT_ARROW */
 {0x50, 0}, /* LEFT_ARROW */
 {0x51, 0}, /* DOWN_ARROW */
 {0x52, 0}, /* UP_ARROW */
 };
 #endif


 uint8_t * USBMouseKeyboard::reportDesc() {
 if (mouse_type == REL_MOUSE) {
 static uint8_t reportDescriptor[] = {
 // Keyboard
 USAGE_PAGE(1), 0x01,
 USAGE(1), 0x06,
 COLLECTION(1), 0x01,
 REPORT_ID(1), REPORT_ID_KEYBOARD,
 USAGE_PAGE(1), 0x07,
 USAGE_MINIMUM(1), 0xE0,
 USAGE_MAXIMUM(1), 0xE7,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 REPORT_SIZE(1), 0x01,
 REPORT_COUNT(1), 0x08,
 INPUT(1), 0x02,
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x08,
 INPUT(1), 0x01,
 REPORT_COUNT(1), 0x05,
 REPORT_SIZE(1), 0x01,
 USAGE_PAGE(1), 0x08,
 USAGE_MINIMUM(1), 0x01,
 USAGE_MAXIMUM(1), 0x05,
 OUTPUT(1), 0x02,
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x03,
 OUTPUT(1), 0x01,
 REPORT_COUNT(1), 0x06,
 REPORT_SIZE(1), 0x08,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(2), 0xff, 0x00,
 USAGE_PAGE(1), 0x07,
 USAGE_MINIMUM(1), 0x00,
 USAGE_MAXIMUM(2), 0xff, 0x00,
 INPUT(1), 0x00,
 END_COLLECTION(0),

 // Mouse
 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x02, // Mouse
 COLLECTION(1), 0x01, // Application
 USAGE(1), 0x01, // Pointer
 COLLECTION(1), 0x00, // Physical
 REPORT_ID(1), REPORT_ID_MOUSE,
 REPORT_COUNT(1), 0x03,
 REPORT_SIZE(1), 0x01,
 USAGE_PAGE(1), 0x09, // Buttons
 USAGE_MINIMUM(1), 0x1,
 USAGE_MAXIMUM(1), 0x3,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 INPUT(1), 0x02,
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x05,
 INPUT(1), 0x01,
 REPORT_COUNT(1), 0x03,
 REPORT_SIZE(1), 0x08,
 USAGE_PAGE(1), 0x01,
 USAGE(1), 0x30, // X
 USAGE(1), 0x31, // Y
 USAGE(1), 0x38, // scroll
 LOGICAL_MINIMUM(1), 0x81,
 LOGICAL_MAXIMUM(1), 0x7f,
 INPUT(1), 0x06,
 END_COLLECTION(0),
 END_COLLECTION(0),


 // Media Control
 USAGE_PAGE(1), 0x0C,
 USAGE(1), 0x01,
 COLLECTION(1), 0x01,
 REPORT_ID(1), REPORT_ID_VOLUME,
 USAGE_PAGE(1), 0x0C,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 REPORT_SIZE(1), 0x01,
 REPORT_COUNT(1), 0x07,
 USAGE(1), 0xB5, // Next Track
 USAGE(1), 0xB6, // Previous Track
 USAGE(1), 0xB7, // Stop
 USAGE(1), 0xCD, // Play / Pause
 USAGE(1), 0xE2, // Mute
 USAGE(1), 0xE9, // Volume Up
 USAGE(1), 0xEA, // Volume Down
 INPUT(1), 0x02, // Input (Data, Variable, Absolute)
 REPORT_COUNT(1), 0x01,
 INPUT(1), 0x01,
 END_COLLECTION(0),
 };
 reportLength = sizeof(reportDescriptor);
 return reportDescriptor;
 } else if (mouse_type == ABS_MOUSE) {
 static uint8_t reportDescriptor[] = {

 // Keyboard
 USAGE_PAGE(1), 0x01,
 USAGE(1), 0x06,
 COLLECTION(1), 0x01,
 REPORT_ID(1), REPORT_ID_KEYBOARD,
 USAGE_PAGE(1), 0x07,
 USAGE_MINIMUM(1), 0xE0,
 USAGE_MAXIMUM(1), 0xE7,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 REPORT_SIZE(1), 0x01,
 REPORT_COUNT(1), 0x08,
 INPUT(1), 0x02,
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x08,
 INPUT(1), 0x01,
 REPORT_COUNT(1), 0x05,
 REPORT_SIZE(1), 0x01,
 USAGE_PAGE(1), 0x08,
 USAGE_MINIMUM(1), 0x01,
 USAGE_MAXIMUM(1), 0x05,
 OUTPUT(1), 0x02,
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x03,
 OUTPUT(1), 0x01,
 REPORT_COUNT(1), 0x06,
 REPORT_SIZE(1), 0x08,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(2), 0xff, 0x00,
 USAGE_PAGE(1), 0x07,
 USAGE_MINIMUM(1), 0x00,
 USAGE_MAXIMUM(2), 0xff, 0x00,
 INPUT(1), 0x00,
 END_COLLECTION(0),

 // Mouse
 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x02, // Mouse
 COLLECTION(1), 0x01, // Application
 USAGE(1), 0x01, // Pointer
 COLLECTION(1), 0x00, // Physical
 REPORT_ID(1), REPORT_ID_MOUSE,

 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x30, // X
 USAGE(1), 0x31, // Y
 LOGICAL_MINIMUM(1), 0x00, // 0
 LOGICAL_MAXIMUM(2), 0xff, 0x7f, // 32767
 REPORT_SIZE(1), 0x10,
 REPORT_COUNT(1), 0x02,
 INPUT(1), 0x02, // Data, Variable, Absolute

 USAGE_PAGE(1), 0x01, // Generic Desktop
 USAGE(1), 0x38, // scroll
 LOGICAL_MINIMUM(1), 0x81, // -127
 LOGICAL_MAXIMUM(1), 0x7f, // 127
 REPORT_SIZE(1), 0x08,
 REPORT_COUNT(1), 0x01,
 INPUT(1), 0x06, // Data, Variable, Relative

 USAGE_PAGE(1), 0x09, // Buttons
 USAGE_MINIMUM(1), 0x01,
 USAGE_MAXIMUM(1), 0x03,
 LOGICAL_MINIMUM(1), 0x00, // 0
 LOGICAL_MAXIMUM(1), 0x01, // 1
 REPORT_COUNT(1), 0x03,
 REPORT_SIZE(1), 0x01,
 INPUT(1), 0x02, // Data, Variable, Absolute
 REPORT_COUNT(1), 0x01,
 REPORT_SIZE(1), 0x05,
 INPUT(1), 0x01, // Constant

 END_COLLECTION(0),
 END_COLLECTION(0),

 // Media Control
 USAGE_PAGE(1), 0x0C,
 USAGE(1), 0x01,
 COLLECTION(1), 0x01,
 REPORT_ID(1), REPORT_ID_VOLUME,
 USAGE_PAGE(1), 0x0C,
 LOGICAL_MINIMUM(1), 0x00,
 LOGICAL_MAXIMUM(1), 0x01,
 REPORT_SIZE(1), 0x01,
 REPORT_COUNT(1), 0x07,
 USAGE(1), 0xB5, // Next Track
 USAGE(1), 0xB6, // Previous Track
 USAGE(1), 0xB7, // Stop
 USAGE(1), 0xCD, // Play / Pause
 USAGE(1), 0xE2, // Mute
 USAGE(1), 0xE9, // Volume Up
 USAGE(1), 0xEA, // Volume Down
 INPUT(1), 0x02, // Input (Data, Variable, Absolute)
 REPORT_COUNT(1), 0x01,
 INPUT(1), 0x01,
 END_COLLECTION(0),
 };
 reportLength = sizeof(reportDescriptor);
 return reportDescriptor;
 }

 return NULL;
 }

 bool USBMouseKeyboard::EPINT_OUT_callback() {
 uint32_t bytesRead = 0;
 uint8_t led[65];
 USBDevice::readEP(EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE);

 // we take led[1] because led[0] is the report ID
 lock_status = led[1] & 0x07;

 // We activate the endpoint to be able to recceive data
 if (!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
 return false;
 return true;
 }

 uint8_t USBMouseKeyboard::lockStatus() {
 return lock_status;
 }

 bool USBMouseKeyboard::update(int16_t x, int16_t y, uint8_t button, int8_t z) {
 switch (mouse_type) {
 case REL_MOUSE:
 while (x > 127) {
 if (!mouseSend(127, 0, button, z)) return false;
 x = x - 127;
 }
 while (x < -128) {
 if (!mouseSend(-128, 0, button, z)) return false;
 x = x + 128;
 }
 while (y > 127) {
 if (!mouseSend(0, 127, button, z)) return false;
 y = y - 127;
 }
 while (y < -128) {
 if (!mouseSend(0, -128, button, z)) return false;
 y = y + 128;
 }
 return mouseSend(x, y, button, z);
 case ABS_MOUSE:
 HID_REPORT report;

 report.data[0] = REPORT_ID_MOUSE;
 report.data[1] = x & 0xff;
 report.data[2] = (x >> 8) & 0xff;
 report.data[3] = y & 0xff;
 report.data[4] = (y >> 8) & 0xff;
 report.data[5] = -z;
 report.data[6] = button & 0x07;

 report.length = 7;

 return send(&report);
 default:
 return false;
 }
 }

 bool USBMouseKeyboard::mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z) {
 HID_REPORT report;
 report.data[0] = REPORT_ID_MOUSE;
 report.data[1] = buttons & 0x07;
 report.data[2] = x;
 report.data[3] = y;
 report.data[4] = -z; // >0 to scroll down, <0 to scroll up

 report.length = 5;

 return send(&report);
 }

 bool USBMouseKeyboard::move(int16_t x, int16_t y) {
 return update(x, y, button, 0);
 }

 bool USBMouseKeyboard::scroll(int8_t z) {
 return update(0, 0, button, z);
 }

 bool USBMouseKeyboard::doubleClick() {
 if (!click(MOUSE_LEFT))
 return false;
 wait(0.1);
 return click(MOUSE_LEFT);
 }

 bool USBMouseKeyboard::click(uint8_t button) {
 if (!update(0, 0, button, 0))
 return false;
 wait(0.01);
 return update(0, 0, 0, 0);
 }

 bool USBMouseKeyboard::press(uint8_t button_) {
 button = button_ & 0x07;
 return update(0, 0, button, 0);
 }

 bool USBMouseKeyboard::release(uint8_t button_) {
 button = (button & (~button_)) & 0x07;
 return update(0, 0, button, 0);
 }

 int USBMouseKeyboard::_putc(int c) {
 return keyCode(c, keymap[c].modifier);
 }

 bool USBMouseKeyboard::keyCode(uint8_t key, uint8_t modifier) {
 // Send a simulated keyboard keypress. Returns true if successful.

 HID_REPORT report;

 report.data[0] = REPORT_ID_KEYBOARD;
 report.data[1] = modifier;
 report.data[2] = 0;
 report.data[3] = keymap[key].usage;
 report.data[4] = 0;
 report.data[5] = 0;
 report.data[6] = 0;
 report.data[7] = 0;
 report.data[8] = 0;

 report.length = 9;

 if (!send(&report)) {
 return false;
 }

 report.data[1] = 0;
 report.data[3] = 0;

 if (!send(&report)) {
 return false;
 }

 return true;

 }


 bool USBMouseKeyboard::mediaControl(MEDIA_KEY key) {
 HID_REPORT report;

 report.data[0] = REPORT_ID_VOLUME;
 report.data[1] = (1 << key) & 0x7f;

 report.length = 2;

 send(&report);

 report.data[0] = REPORT_ID_VOLUME;
 report.data[1] = 0;

 report.length = 2;

 return send(&report);
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBHID/USBMouseKeyboard.h
@@ -0,0 +1,220 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBMOUSEKEYBOARD_H
 #define USBMOUSEKEYBOARD_H

 #define REPORT_ID_KEYBOARD 1
 #define REPORT_ID_MOUSE 2
 #define REPORT_ID_VOLUME 3

 #include "USBMouse.h"
 #include "USBKeyboard.h"
 #include "Stream.h"
 #include "USBHID.h"

 /**
 * USBMouseKeyboard example
 * @code
 *
 * #include "mbed.h"
 * #include "USBMouseKeyboard.h"
 *
 * USBMouseKeyboard key_mouse;
 *
 * int main(void)
 * {
 * while(1)
 * {
 * key_mouse.move(20, 0);
 * key_mouse.printf("Hello From MBED\r\n");
 * wait(1);
 * }
 * }
 * @endcode
 *
 *
 * @code
 *
 * #include "mbed.h"
 * #include "USBMouseKeyboard.h"
 *
 * USBMouseKeyboard key_mouse(ABS_MOUSE);
 *
 * int main(void)
 * {
 * while(1)
 * {
 * key_mouse.move(X_MAX_ABS/2, Y_MAX_ABS/2);
 * key_mouse.printf("Hello from MBED\r\n");
 * wait(1);
 * }
 * }
 * @endcode
 */
 class USBMouseKeyboard: public USBHID, public Stream
 {
 public:

 /**
 * Constructor
 *
 * @param mouse_type Mouse type: ABS_MOUSE (absolute mouse) or REL_MOUSE (relative mouse) (default: REL_MOUSE)
 * @param leds Leds bus: first: NUM_LOCK, second: CAPS_LOCK, third: SCROLL_LOCK
 * @param vendor_id Your vendor_id (default: 0x1234)
 * @param product_id Your product_id (default: 0x0001)
 * @param product_release Your preoduct_release (default: 0x0001)
 *
 */
 USBMouseKeyboard(MOUSE_TYPE mouse_type = REL_MOUSE, uint16_t vendor_id = 0x0021, uint16_t product_id = 0x0011, uint16_t product_release = 0x0001):
 USBHID(0, 0, vendor_id, product_id, product_release, false)
 {
 lock_status = 0;
 button = 0;
 this->mouse_type = mouse_type;
 connect();
 };

 /**
 * Write a state of the mouse
 *
 * @param x x-axis position
 * @param y y-axis position
 * @param buttons buttons state (first bit represents MOUSE_LEFT, second bit MOUSE_RIGHT and third bit MOUSE_MIDDLE)
 * @param z wheel state (>0 to scroll down, <0 to scroll up)
 * @returns true if there is no error, false otherwise
 */
 bool update(int16_t x, int16_t y, uint8_t buttons, int8_t z);


 /**
 * Move the cursor to (x, y)
 *
 * @param x x-axis position
 * @param y y-axis position
 * @returns true if there is no error, false otherwise
 */
 bool move(int16_t x, int16_t y);

 /**
 * Press one or several buttons
 *
 * @param button button state (ex: press(MOUSE_LEFT))
 * @returns true if there is no error, false otherwise
 */
 bool press(uint8_t button);

 /**
 * Release one or several buttons
 *
 * @param button button state (ex: release(MOUSE_LEFT))
 * @returns true if there is no error, false otherwise
 */
 bool release(uint8_t button);

 /**
 * Double click (MOUSE_LEFT)
 *
 * @returns true if there is no error, false otherwise
 */
 bool doubleClick();

 /**
 * Click
 *
 * @param button state of the buttons ( ex: clic(MOUSE_LEFT))
 * @returns true if there is no error, false otherwise
 */
 bool click(uint8_t button);

 /**
 * Scrolling
 *
 * @param z value of the wheel (>0 to go down, <0 to go up)
 * @returns true if there is no error, false otherwise
 */
 bool scroll(int8_t z);

 /**
 * To send a character defined by a modifier(CTRL, SHIFT, ALT) and the key
 *
 * @code
 * //To send CTRL + s (save)
 * keyboard.keyCode('s', KEY_CTRL);
 * @endcode
 *
 * @param modifier bit 0: KEY_CTRL, bit 1: KEY_SHIFT, bit 2: KEY_ALT (default: 0)
 * @param key character to send
 * @returns true if there is no error, false otherwise
 */
 bool keyCode(uint8_t key, uint8_t modifier = 0);

 /**
 * Send a character
 *
 * @param c character to be sent
 * @returns true if there is no error, false otherwise
 */
 virtual int _putc(int c);

 /**
 * Control media keys
 *
 * @param key media key pressed (KEY_NEXT_TRACK, KEY_PREVIOUS_TRACK, KEY_STOP, KEY_PLAY_PAUSE, KEY_MUTE, KEY_VOLUME_UP, KEY_VOLUME_DOWN)
 * @returns true if there is no error, false otherwise
 */
 bool mediaControl(MEDIA_KEY key);

 /**
 * Read status of lock keys. Useful to switch-on/off leds according to key pressed. Only the first three bits of the result is important:
 * - First bit: NUM_LOCK
 * - Second bit: CAPS_LOCK
 * - Third bit: SCROLL_LOCK
 *
 * @returns status of lock keys
 */
 uint8_t lockStatus();

 /*
 * To define the report descriptor. Warning: this method has to store the length of the report descriptor in reportLength.
 *
 * @returns pointer to the report descriptor
 */
 virtual uint8_t * reportDesc();

 /*
 * Called when a data is received on the OUT endpoint. Useful to switch on LED of LOCK keys
 *
 * @returns if handle by subclass, return true
 */
 virtual bool EPINT_OUT_callback();


 private:
 bool mouseWrite(int8_t x, int8_t y, uint8_t buttons, int8_t z);
 MOUSE_TYPE mouse_type;
 uint8_t button;
 bool mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z);

 uint8_t lock_status;

 //dummy otherwise it doesn't compile (we must define all methods of an abstract class)
 virtual int _getc() { return -1;}
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/MIDIMessage.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/MIDIMessage.h
@@ -0,0 +1,276 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef MIDIMESSAGE_H
 #define MIDIMESSAGE_H

 #include "mbed.h"

 #define MAX_MIDI_MESSAGE_SIZE 256 // Max message size. SysEx can be up to 65536 but 256 should be fine for most usage

 // MIDI Message Format
 //
 // [ msg(4) | channel(4) ] [ 0 | n(7) ] [ 0 | m(7) ]
 //
 // MIDI Data Messages (Channel Specific)
 //
 // Message msg n m
 // ---------------------------------------------
 // Note Off 0x8 Key Velocity
 // Note On 0x9 Key Velocity
 // Polyphonic Aftertouch 0xA Key Pressure
 // Control Change 0xB Controller Value
 // Program Change 0xC Program -
 // Channel Aftertouch 0xD Pressure -
 // Pitch Wheel 0xE LSB MSB

 #define CABLE_NUM (0<<4)

 /** A MIDI message container */
 class MIDIMessage {
 public:
 MIDIMessage() : length(4) {}

 MIDIMessage(uint8_t *buf) : length(4) {
 for (int i = 0; i < 4; i++)
 data[i] = buf[i];
 }

 // New constructor, buf is a true MIDI message (not USBMidi message) and buf_len true message length.
 MIDIMessage(uint8_t *buf, int buf_len) {
 length=buf_len+1;
 // first byte keeped for retro-compatibility
 data[0]=0;

 for (int i = 0; i < buf_len; i++)
 data[i+1] = buf[i];
 }

 // create messages

 /** Create a NoteOff message
 * @param key Key ID
 * @param velocity Key velocity (0-127, default = 127)
 * @param channel Key channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage NoteOff(int key, int velocity = 127, int channel = 0) {
 MIDIMessage msg;
 msg.data[0] = CABLE_NUM | 0x08;
 msg.data[1] = 0x80 | (channel & 0x0F);
 msg.data[2] = key & 0x7F;
 msg.data[3] = velocity & 0x7F;
 return msg;
 }

 /** Create a NoteOn message
 * @param key Key ID
 * @param velocity Key velocity (0-127, default = 127)
 * @param channel Key channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage NoteOn(int key, int velocity = 127, int channel = 0) {
 MIDIMessage msg;
 msg.data[0] = CABLE_NUM | 0x09;
 msg.data[1] = 0x90 | (channel & 0x0F);
 msg.data[2] = key & 0x7F;
 msg.data[3] = velocity & 0x7F;
 return msg;
 }

 /** Create a PolyPhonic Aftertouch message
 * @param key Key ID
 * @param pressure Aftertouch pressure (0-127)
 * @param channel Key channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage PolyphonicAftertouch(int key, int pressure, int channel = 0) {
 MIDIMessage msg;
 msg.data[0] = CABLE_NUM | 0x0A;
 msg.data[1] = 0xA0 | (channel & 0x0F);
 msg.data[2] = key & 0x7F;
 msg.data[3] = pressure & 0x7F;
 return msg;
 }

 /** Create a Control Change message
 * @param control Controller ID
 * @param value Controller value (0-127)
 * @param channel Controller channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage ControlChange(int control, int value, int channel = 0) {
 MIDIMessage msg;
 msg.data[0] = CABLE_NUM | 0x0B;
 msg.data[1] = 0xB0 | (channel & 0x0F);
 msg.data[2] = control & 0x7F;
 msg.data[3] = value & 0x7F;
 return msg;
 }

 /** Create a Program Change message
 * @param program Program ID
 * @param channel Channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage ProgramChange(int program, int channel = 0) {
 MIDIMessage msg;
 msg.data[0] = CABLE_NUM | 0x0C;
 msg.data[1] = 0xC0 | (channel & 0x0F);
 msg.data[2] = program & 0x7F;
 msg.data[3] = 0x00;
 return msg;
 }

 /** Create a Channel Aftertouch message
 * @param pressure Pressure
 * @param channel Key channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage ChannelAftertouch(int pressure, int channel = 0) {
 MIDIMessage msg;
 msg.data[0] = CABLE_NUM | 0x0D;
 msg.data[1] = 0xD0 | (channel & 0x0F);
 msg.data[2] = pressure & 0x7F;
 msg.data[3] = 0x00;
 return msg;
 }

 /** Create a Pitch Wheel message
 * @param pitch Pitch (-8192 - 8191, default = 0)
 * @param channel Channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage PitchWheel(int pitch = 0, int channel = 0) {
 MIDIMessage msg;
 int p = pitch + 8192; // 0 - 16383, 8192 is center
 msg.data[0] = CABLE_NUM | 0x0E;
 msg.data[1] = 0xE0 | (channel & 0x0F);
 msg.data[2] = p & 0x7F;
 msg.data[3] = (p >> 7) & 0x7F;
 return msg;
 }

 /** Create an All Notes Off message
 * @param channel Channel (0-15, default 0)
 * @returns A MIDIMessage
 */
 static MIDIMessage AllNotesOff(int channel = 0) {
 return ControlChange(123, 0, channel);
 }

 /** Create a SysEx message
 * @param data SysEx data (including 0xF0 .. 0xF7)
 * @param len SysEx data length
 * @returns A MIDIMessage
 */
 static MIDIMessage SysEx(uint8_t *data, int len) {
 MIDIMessage msg=MIDIMessage(data,len);
 return msg;
 }

 // decode messages

 /** MIDI Message Types */
 enum MIDIMessageType {
 ErrorType,
 NoteOffType,
 NoteOnType,
 PolyphonicAftertouchType,
 ControlChangeType,
 ProgramChangeType,
 ChannelAftertouchType,
 PitchWheelType,
 AllNotesOffType,
 SysExType
 };

 /** Read the message type
 * @returns MIDIMessageType
 */
 MIDIMessageType type() {
 switch((data[1] >> 4) & 0xF) {
 case 0x8: return NoteOffType;
 case 0x9: return NoteOnType;
 case 0xA: return PolyphonicAftertouchType;
 case 0xB:
 if(controller() < 120) { // standard controllers
 return ControlChangeType;
 } else if(controller() == 123) {
 return AllNotesOffType;
 } else {
 return ErrorType; // unsupported atm
 }
 case 0xC: return ProgramChangeType;
 case 0xD: return ChannelAftertouchType;
 case 0xE: return PitchWheelType;
 case 0xF: return SysExType;
 default: return ErrorType;
 }
 }

 /** Read the channel number */
 int channel() {
 return (data[1] & 0x0F);
 }

 /** Read the key ID */
 int key() {
 return (data[2] & 0x7F);
 }

 /** Read the velocity */
 int velocity() {
 return (data[3] & 0x7F);
 }

 /** Read the controller value */
 int value() {
 return (data[3] & 0x7F);
 }

 /** Read the aftertouch pressure */
 int pressure() {
 if(type() == PolyphonicAftertouchType) {
 return (data[3] & 0x7F);
 } else {
 return (data[2] & 0x7F);
 }
 }

 /** Read the controller number */
 int controller() {
 return (data[2] & 0x7F);
 }

 /** Read the program number */
 int program() {
 return (data[2] & 0x7F);
 }

 /** Read the pitch value */
 int pitch() {
 int p = ((data[3] & 0x7F) << 7) | (data[2] & 0x7F);
 return p - 8192; // 0 - 16383, 8192 is center
 }

 uint8_t data[MAX_MIDI_MESSAGE_SIZE+1];
 uint8_t length;
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.cpp
@@ -0,0 +1,207 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBMIDI.h"


 USBMIDI::USBMIDI(uint16_t vendor_id, uint16_t product_id, uint16_t product_release)
 : USBDevice(vendor_id, product_id, product_release), cur_data(0), data_end(true)
 {
 midi_evt = NULL;
 USBDevice::connect();
 }

 // write plain MIDIMessage that will be converted to USBMidi event packet
 void USBMIDI::write(MIDIMessage m) {
 // first byte keeped for retro-compatibility
 for(int p=1; p < m.length; p+=3) {
 uint8_t buf[4];
 // Midi message to USBMidi event packet
 buf[0]=m.data[1] >> 4;
 // SysEx
 if(buf[0] == 0xF) {
 if((m.length - p) > 3) {
 // SysEx start or continue
 buf[0]=0x4;
 } else {
 switch(m.length - p) {
 case 1:
 // SysEx end with one byte
 buf[0]=0x5;
 break;
 case 2:
 // SysEx end with two bytes
 buf[0]=0x6;
 break;
 case 3:
 // SysEx end with three bytes
 buf[0]=0x7;
 break;
 }
 }
 }
 buf[1]=m.data[p];

 if(p+1 < m.length)
 buf[2]=m.data[p+1];
 else
 buf[2]=0;

 if(p+2 < m.length)
 buf[3]=m.data[p+2];
 else
 buf[3]=0;

 USBDevice::write(EPBULK_IN, buf, 4, MAX_PACKET_SIZE_EPBULK);
 }
 }


 void USBMIDI::attach(void (*fptr)(MIDIMessage)) {
 midi_evt = fptr;
 }

 bool USBMIDI::EPBULK_OUT_callback() {
 uint8_t buf[64];
 uint32_t len;
 readEP(EPBULK_OUT, buf, &len, 64);

 if (midi_evt != NULL) {
 for (uint32_t i=0; i<len; i+=4) { 
 uint8_t data_read;
 data_end=true;
 switch(buf[i]) {
 case 0x2:
 // Two-bytes System Common Message - undefined in USBMidi 1.0
 data_read=2;
 break;
 case 0x4:
 // SysEx start or continue
 data_end=false;
 data_read=3;
 break;
 case 0x5:
 // Single-byte System Common Message or SysEx end with one byte
 data_read=1;
 break;
 case 0x6:
 // SysEx end with two bytes
 data_read=2;
 break;
 case 0xC:
 // Program change
 data_read=2;
 break;
 case 0xD:
 // Channel pressure
 data_read=2;
 break; 
 case 0xF:
 // Single byte
 data_read=1;
 break; 
 default:
 // Others three-bytes messages
 data_read=3;
 break; 
 } 
 
 for(uint8_t j=1;j<data_read+1;j++) {
 data[cur_data]=buf[i+j];
 cur_data++;
 }
 
 if(data_end) {
 midi_evt(MIDIMessage(data,cur_data));
 cur_data=0; 
 }
 }
 }

 // We reactivate the endpoint to receive next characters
 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
 return true;
 }

 // Called in ISR context
 // Set configuration. Return false if the
 // configuration is not supported.
 bool USBMIDI::USBCallback_setConfiguration(uint8_t configuration) {
 if (configuration != DEFAULT_CONFIGURATION) {
 return false;
 }

 // Configure endpoints > 0
 addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
 addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);

 // We activate the endpoint to be able to receive data
 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
 return true;
 }


 uint8_t * USBMIDI::stringIinterfaceDesc() {
 static uint8_t stringIinterfaceDescriptor[] = {
 0x0c, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'A',0,'u',0,'d',0,'i',0,'o',0 //bString iInterface - Audio
 };
 return stringIinterfaceDescriptor;
 }

 uint8_t * USBMIDI::stringIproductDesc() {
 static uint8_t stringIproductDescriptor[] = {
 0x16, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'M',0,'b',0,'e',0,'d',0,' ',0,'A',0,'u',0,'d',0,'i',0,'o',0 //bString iProduct - Mbed Audio
 };
 return stringIproductDescriptor;
 }


 uint8_t * USBMIDI::configurationDesc() {
 static uint8_t configDescriptor[] = {
 // configuration descriptor
 0x09, 0x02, 0x65, 0x00, 0x02, 0x01, 0x00, 0xc0, 0x50,

 // The Audio Interface Collection
 0x09, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, // Standard AC Interface Descriptor
 0x09, 0x24, 0x01, 0x00, 0x01, 0x09, 0x00, 0x01, 0x01, // Class-specific AC Interface Descriptor
 0x09, 0x04, 0x01, 0x00, 0x02, 0x01, 0x03, 0x00, 0x00, // MIDIStreaming Interface Descriptors
 0x07, 0x24, 0x01, 0x00, 0x01, 0x41, 0x00, // Class-Specific MS Interface Header Descriptor

 // MIDI IN JACKS
 0x06, 0x24, 0x02, 0x01, 0x01, 0x00,
 0x06, 0x24, 0x02, 0x02, 0x02, 0x00,

 // MIDI OUT JACKS
 0x09, 0x24, 0x03, 0x01, 0x03, 0x01, 0x02, 0x01, 0x00,
 0x09, 0x24, 0x03, 0x02, 0x06, 0x01, 0x01, 0x01, 0x00,

 // OUT endpoint descriptor
 0x09, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
 0x05, 0x25, 0x01, 0x01, 0x01,

 // IN endpoint descriptor
 0x09, 0x05, 0x82, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
 0x05, 0x25, 0x01, 0x01, 0x03,
 };
 return configDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMIDI/USBMIDI.h
@@ -0,0 +1,112 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBMIDI_H
 #define USBMIDI_H

 /* These headers are included for child class. */
 #include "USBEndpoints.h"
 #include "USBDescriptor.h"
 #include "USBDevice_Types.h"

 #include "USBDevice.h"
 #include "MIDIMessage.h"

 #define DEFAULT_CONFIGURATION (1)

 /**
 * USBMIDI example
 *
 * @code
 * #include "mbed.h"
 * #include "USBMIDI.h"
 *
 * USBMIDI midi;
 *
 * int main() {
 * while (1) {
 * for(int i=48; i<83; i++) { // send some messages!
 * midi.write(MIDIMessage::NoteOn(i));
 * wait(0.25);
 * midi.write(MIDIMessage::NoteOff(i));
 * wait(0.5);
 * }
 * }
 * }
 * @endcode
 */
 class USBMIDI: public USBDevice {
 public:

 /**
 * Constructor
 *
 * @param vendor_id Your vendor_id
 * @param product_id Your product_id
 * @param product_release Your preoduct_release
 */
 USBMIDI(uint16_t vendor_id = 0x0700, uint16_t product_id = 0x0101, uint16_t product_release = 0x0001);

 /**
 * Send a MIDIMessage
 *
 * @param m The MIDIMessage to send
 */
 void write(MIDIMessage m);

 /**
 * Attach a callback for when a MIDIEvent is received
 *
 * @param fptr function pointer
 */
 void attach(void (*fptr)(MIDIMessage));


 protected:
 virtual bool EPBULK_OUT_callback();
 virtual bool USBCallback_setConfiguration(uint8_t configuration);
 /*
 * Get string product descriptor
 *
 * @returns pointer to the string product descriptor
 */
 virtual uint8_t * stringIproductDesc();

 /*
 * Get string interface descriptor
 *
 * @returns pointer to the string interface descriptor
 */
 virtual uint8_t * stringIinterfaceDesc();

 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();

 private:
 uint8_t data[MAX_MIDI_MESSAGE_SIZE+1];
 uint8_t cur_data;
 bool data_end;
 
 void (*midi_evt)(MIDIMessage);
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.cpp
@@ -0,0 +1,655 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBMSD.h"

 #define DISK_OK 0x00
 #define NO_INIT 0x01
 #define NO_DISK 0x02
 #define WRITE_PROTECT 0x04

 #define CBW_Signature 0x43425355
 #define CSW_Signature 0x53425355

 // SCSI Commands
 #define TEST_UNIT_READY 0x00
 #define REQUEST_SENSE 0x03
 #define FORMAT_UNIT 0x04
 #define INQUIRY 0x12
 #define MODE_SELECT6 0x15
 #define MODE_SENSE6 0x1A
 #define START_STOP_UNIT 0x1B
 #define MEDIA_REMOVAL 0x1E
 #define READ_FORMAT_CAPACITIES 0x23
 #define READ_CAPACITY 0x25
 #define READ10 0x28
 #define WRITE10 0x2A
 #define VERIFY10 0x2F
 #define READ12 0xA8
 #define WRITE12 0xAA
 #define MODE_SELECT10 0x55
 #define MODE_SENSE10 0x5A

 // MSC class specific requests
 #define MSC_REQUEST_RESET 0xFF
 #define MSC_REQUEST_GET_MAX_LUN 0xFE

 #define DEFAULT_CONFIGURATION (1)

 // max packet size
 #define MAX_PACKET MAX_PACKET_SIZE_EPBULK

 // CSW Status
 enum Status {
 CSW_PASSED,
 CSW_FAILED,
 CSW_ERROR,
 };


 USBMSD::USBMSD(uint16_t vendor_id, uint16_t product_id, uint16_t product_release): USBDevice(vendor_id, product_id, product_release) {
 stage = READ_CBW;
 memset((void *)&cbw, 0, sizeof(CBW));
 memset((void *)&csw, 0, sizeof(CSW));
 page = NULL;
 }

 USBMSD::~USBMSD() {
 disconnect();
 }


 // Called in ISR context to process a class specific request
 bool USBMSD::USBCallback_request(void) {

 bool success = false;
 CONTROL_TRANSFER * transfer = getTransferPtr();
 static uint8_t maxLUN[1] = {0};

 if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
 switch (transfer->setup.bRequest) {
 case MSC_REQUEST_RESET:
 reset();
 success = true;
 break;
 case MSC_REQUEST_GET_MAX_LUN:
 transfer->remaining = 1;
 transfer->ptr = maxLUN;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;
 default:
 break;
 }
 }

 return success;
 }


 bool USBMSD::connect(bool blocking) {
 //disk initialization
 if (disk_status() & NO_INIT) {
 if (disk_initialize()) {
 return false;
 }
 }

 // get number of blocks
 BlockCount = disk_sectors();

 // get memory size
 MemorySize = disk_size();

 if (BlockCount > 0) {
 BlockSize = MemorySize / BlockCount;
 if (BlockSize != 0) {
 free(page);
 page = (uint8_t *)malloc(BlockSize * sizeof(uint8_t));
 if (page == NULL)
 return false;
 }
 } else {
 return false;
 }

 //connect the device
 USBDevice::connect(blocking);
 return true;
 }

 void USBMSD::disconnect() {
 USBDevice::disconnect();
 //De-allocate MSD page size:
 free(page);
 page = NULL;
 }

 void USBMSD::reset() {
 stage = READ_CBW;
 }


 // Called in ISR context called when a data is received
 bool USBMSD::EPBULK_OUT_callback() {
 uint32_t size = 0;
 uint8_t buf[MAX_PACKET_SIZE_EPBULK];
 readEP(EPBULK_OUT, buf, &size, MAX_PACKET_SIZE_EPBULK);
 switch (stage) {
 // the device has to decode the CBW received
 case READ_CBW:
 CBWDecode(buf, size);
 break;

 // the device has to receive data from the host
 case PROCESS_CBW:
 switch (cbw.CB[0]) {
 case WRITE10:
 case WRITE12:
 memoryWrite(buf, size);
 break;
 case VERIFY10:
 memoryVerify(buf, size);
 break;
 }
 break;

 // an error has occured: stall endpoint and send CSW
 default:
 stallEndpoint(EPBULK_OUT);
 csw.Status = CSW_ERROR;
 sendCSW();
 break;
 }

 //reactivate readings on the OUT bulk endpoint
 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
 return true;
 }

 // Called in ISR context when a data has been transferred
 bool USBMSD::EPBULK_IN_callback() {
 switch (stage) {

 // the device has to send data to the host
 case PROCESS_CBW:
 switch (cbw.CB[0]) {
 case READ10:
 case READ12:
 memoryRead();
 break;
 }
 break;

 //the device has to send a CSW
 case SEND_CSW:
 sendCSW();
 break;

 // the host has received the CSW -> we wait a CBW
 case WAIT_CSW:
 stage = READ_CBW;
 break;

 // an error has occured
 default:
 stallEndpoint(EPBULK_IN);
 sendCSW();
 break;
 }
 return true;
 }


 void USBMSD::memoryWrite (uint8_t * buf, uint16_t size) {

 if ((addr + size) > MemorySize) {
 size = MemorySize - addr;
 stage = ERROR;
 stallEndpoint(EPBULK_OUT);
 }

 // we fill an array in RAM of 1 block before writing it in memory
 for (int i = 0; i < size; i++)
 page[addr%BlockSize + i] = buf[i];

 // if the array is filled, write it in memory
 if (!((addr + size)%BlockSize)) {
 if (!(disk_status() & WRITE_PROTECT)) {
 disk_write(page, addr/BlockSize, 1);
 }
 }

 addr += size;
 length -= size;
 csw.DataResidue -= size;

 if ((!length) || (stage != PROCESS_CBW)) {
 csw.Status = (stage == ERROR) ? CSW_FAILED : CSW_PASSED;
 sendCSW();
 }
 }

 void USBMSD::memoryVerify (uint8_t * buf, uint16_t size) {
 uint32_t n;

 if ((addr + size) > MemorySize) {
 size = MemorySize - addr;
 stage = ERROR;
 stallEndpoint(EPBULK_OUT);
 }

 // beginning of a new block -> load a whole block in RAM
 if (!(addr%BlockSize))
 disk_read(page, addr/BlockSize, 1);

 // info are in RAM -> no need to re-read memory
 for (n = 0; n < size; n++) {
 if (page[addr%BlockSize + n] != buf[n]) {
 memOK = false;
 break;
 }
 }

 addr += size;
 length -= size;
 csw.DataResidue -= size;

 if ( !length || (stage != PROCESS_CBW)) {
 csw.Status = (memOK && (stage == PROCESS_CBW)) ? CSW_PASSED : CSW_FAILED;
 sendCSW();
 }
 }


 bool USBMSD::inquiryRequest (void) {
 uint8_t inquiry[] = { 0x00, 0x80, 0x00, 0x01,
 36 - 4, 0x80, 0x00, 0x00,
 'M', 'B', 'E', 'D', '.', 'O', 'R', 'G',
 'M', 'B', 'E', 'D', ' ', 'U', 'S', 'B', ' ', 'D', 'I', 'S', 'K', ' ', ' ', ' ',
 '1', '.', '0', ' ',
 };
 if (!write(inquiry, sizeof(inquiry))) {
 return false;
 }
 return true;
 }


 bool USBMSD::readFormatCapacity() {
 uint8_t capacity[] = { 0x00, 0x00, 0x00, 0x08,
 (uint8_t)((BlockCount >> 24) & 0xff),
 (uint8_t)((BlockCount >> 16) & 0xff),
 (uint8_t)((BlockCount >> 8) & 0xff),
 (uint8_t)((BlockCount >> 0) & 0xff),

 0x02,
 (uint8_t)((BlockSize >> 16) & 0xff),
 (uint8_t)((BlockSize >> 8) & 0xff),
 (uint8_t)((BlockSize >> 0) & 0xff),
 };
 if (!write(capacity, sizeof(capacity))) {
 return false;
 }
 return true;
 }


 bool USBMSD::readCapacity (void) {
 uint8_t capacity[] = {
 (uint8_t)(((BlockCount - 1) >> 24) & 0xff),
 (uint8_t)(((BlockCount - 1) >> 16) & 0xff),
 (uint8_t)(((BlockCount - 1) >> 8) & 0xff),
 (uint8_t)(((BlockCount - 1) >> 0) & 0xff),

 (uint8_t)((BlockSize >> 24) & 0xff),
 (uint8_t)((BlockSize >> 16) & 0xff),
 (uint8_t)((BlockSize >> 8) & 0xff),
 (uint8_t)((BlockSize >> 0) & 0xff),
 };
 if (!write(capacity, sizeof(capacity))) {
 return false;
 }
 return true;
 }

 bool USBMSD::write (uint8_t * buf, uint16_t size) {

 if (size >= cbw.DataLength) {
 size = cbw.DataLength;
 }
 stage = SEND_CSW;

 if (!writeNB(EPBULK_IN, buf, size, MAX_PACKET_SIZE_EPBULK)) {
 return false;
 }

 csw.DataResidue -= size;
 csw.Status = CSW_PASSED;
 return true;
 }


 bool USBMSD::modeSense6 (void) {
 uint8_t sense6[] = { 0x03, 0x00, 0x00, 0x00 };
 if (!write(sense6, sizeof(sense6))) {
 return false;
 }
 return true;
 }

 void USBMSD::sendCSW() {
 csw.Signature = CSW_Signature;
 writeNB(EPBULK_IN, (uint8_t *)&csw, sizeof(CSW), MAX_PACKET_SIZE_EPBULK);
 stage = WAIT_CSW;
 }

 bool USBMSD::requestSense (void) {
 uint8_t request_sense[] = {
 0x70,
 0x00,
 0x05, // Sense Key: illegal request
 0x00,
 0x00,
 0x00,
 0x00,
 0x0A,
 0x00,
 0x00,
 0x00,
 0x00,
 0x30,
 0x01,
 0x00,
 0x00,
 0x00,
 0x00,
 };

 if (!write(request_sense, sizeof(request_sense))) {
 return false;
 }

 return true;
 }

 void USBMSD::fail() {
 csw.Status = CSW_FAILED;
 sendCSW();
 }


 void USBMSD::CBWDecode(uint8_t * buf, uint16_t size) {
 if (size == sizeof(cbw)) {
 memcpy((uint8_t *)&cbw, buf, size);
 if (cbw.Signature == CBW_Signature) {
 csw.Tag = cbw.Tag;
 csw.DataResidue = cbw.DataLength;
 if ((cbw.CBLength < 1) || (cbw.CBLength > 16) ) {
 fail();
 } else {
 switch (cbw.CB[0]) {
 case TEST_UNIT_READY:
 testUnitReady();
 break;
 case REQUEST_SENSE:
 requestSense();
 break;
 case INQUIRY:
 inquiryRequest();
 break;
 case MODE_SENSE6:
 modeSense6();
 break;
 case READ_FORMAT_CAPACITIES:
 readFormatCapacity();
 break;
 case READ_CAPACITY:
 readCapacity();
 break;
 case READ10:
 case READ12:
 if (infoTransfer()) {
 if ((cbw.Flags & 0x80)) {
 stage = PROCESS_CBW;
 memoryRead();
 } else {
 stallEndpoint(EPBULK_OUT);
 csw.Status = CSW_ERROR;
 sendCSW();
 }
 }
 break;
 case WRITE10:
 case WRITE12:
 if (infoTransfer()) {
 if (!(cbw.Flags & 0x80)) {
 stage = PROCESS_CBW;
 } else {
 stallEndpoint(EPBULK_IN);
 csw.Status = CSW_ERROR;
 sendCSW();
 }
 }
 break;
 case VERIFY10:
 if (!(cbw.CB[1] & 0x02)) {
 csw.Status = CSW_PASSED;
 sendCSW();
 break;
 }
 if (infoTransfer()) {
 if (!(cbw.Flags & 0x80)) {
 stage = PROCESS_CBW;
 memOK = true;
 } else {
 stallEndpoint(EPBULK_IN);
 csw.Status = CSW_ERROR;
 sendCSW();
 }
 }
 break;
 case MEDIA_REMOVAL:
 csw.Status = CSW_PASSED;
 sendCSW();
 break;
 default:
 fail();
 break;
 }
 }
 }
 }
 }

 void USBMSD::testUnitReady (void) {

 if (cbw.DataLength != 0) {
 if ((cbw.Flags & 0x80) != 0) {
 stallEndpoint(EPBULK_IN);
 } else {
 stallEndpoint(EPBULK_OUT);
 }
 }

 csw.Status = CSW_PASSED;
 sendCSW();
 }


 void USBMSD::memoryRead (void) {
 uint32_t n;

 n = (length > MAX_PACKET) ? MAX_PACKET : length;

 if ((addr + n) > MemorySize) {
 n = MemorySize - addr;
 stage = ERROR;
 }

 // we read an entire block
 if (!(addr%BlockSize))
 disk_read(page, addr/BlockSize, 1);

 // write data which are in RAM
 writeNB(EPBULK_IN, &page[addr%BlockSize], n, MAX_PACKET_SIZE_EPBULK);

 addr += n;
 length -= n;

 csw.DataResidue -= n;

 if ( !length || (stage != PROCESS_CBW)) {
 csw.Status = (stage == PROCESS_CBW) ? CSW_PASSED : CSW_FAILED;
 stage = (stage == PROCESS_CBW) ? SEND_CSW : stage;
 }
 }


 bool USBMSD::infoTransfer (void) {
 uint32_t n;

 // Logical Block Address of First Block
 n = (cbw.CB[2] << 24) | (cbw.CB[3] << 16) | (cbw.CB[4] << 8) | (cbw.CB[5] << 0);

 addr = n * BlockSize;

 // Number of Blocks to transfer
 switch (cbw.CB[0]) {
 case READ10:
 case WRITE10:
 case VERIFY10:
 n = (cbw.CB[7] << 8) | (cbw.CB[8] << 0);
 break;

 case READ12:
 case WRITE12:
 n = (cbw.CB[6] << 24) | (cbw.CB[7] << 16) | (cbw.CB[8] << 8) | (cbw.CB[9] << 0);
 break;
 }

 length = n * BlockSize;

 if (!cbw.DataLength) { // host requests no data
 csw.Status = CSW_FAILED;
 sendCSW();
 return false;
 }

 if (cbw.DataLength != length) {
 if ((cbw.Flags & 0x80) != 0) {
 stallEndpoint(EPBULK_IN);
 } else {
 stallEndpoint(EPBULK_OUT);
 }

 csw.Status = CSW_FAILED;
 sendCSW();
 return false;
 }

 return true;
 }





 // Called in ISR context
 // Set configuration. Return false if the
 // configuration is not supported.
 bool USBMSD::USBCallback_setConfiguration(uint8_t configuration) {
 if (configuration != DEFAULT_CONFIGURATION) {
 return false;
 }

 // Configure endpoints > 0
 addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
 addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);

 //activate readings
 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
 return true;
 }


 uint8_t * USBMSD::stringIinterfaceDesc() {
 static uint8_t stringIinterfaceDescriptor[] = {
 0x08, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'M',0,'S',0,'D',0 //bString iInterface - MSD
 };
 return stringIinterfaceDescriptor;
 }

 uint8_t * USBMSD::stringIproductDesc() {
 static uint8_t stringIproductDescriptor[] = {
 0x12, //bLength
 STRING_DESCRIPTOR, //bDescriptorType 0x03
 'M',0,'b',0,'e',0,'d',0,' ',0,'M',0,'S',0,'D',0 //bString iProduct - Mbed Audio
 };
 return stringIproductDescriptor;
 }


 uint8_t * USBMSD::configurationDesc() {
 static uint8_t configDescriptor[] = {

 // Configuration 1
 9, // bLength
 2, // bDescriptorType
 LSB(9 + 9 + 7 + 7), // wTotalLength
 MSB(9 + 9 + 7 + 7),
 0x01, // bNumInterfaces
 0x01, // bConfigurationValue: 0x01 is used to select this configuration
 0x00, // iConfiguration: no string to describe this configuration
 0xC0, // bmAttributes
 100, // bMaxPower, device power consumption is 100 mA

 // Interface 0, Alternate Setting 0, MSC Class
 9, // bLength
 4, // bDescriptorType
 0x00, // bInterfaceNumber
 0x00, // bAlternateSetting
 0x02, // bNumEndpoints
 0x08, // bInterfaceClass
 0x06, // bInterfaceSubClass
 0x50, // bInterfaceProtocol
 0x04, // iInterface

 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 7, // bLength
 5, // bDescriptorType
 PHY_TO_DESC(EPBULK_IN), // bEndpointAddress
 0x02, // bmAttributes (0x02=bulk)
 LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB)
 0, // bInterval

 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 7, // bLength
 5, // bDescriptorType
 PHY_TO_DESC(EPBULK_OUT), // bEndpointAddress
 0x02, // bmAttributes (0x02=bulk)
 LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB)
 0 // bInterval
 };
 return configDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBMSD/USBMSD.h
@@ -0,0 +1,251 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */


 #ifndef USBMSD_H
 #define USBMSD_H

 /* These headers are included for child class. */
 #include "USBEndpoints.h"
 #include "USBDescriptor.h"
 #include "USBDevice_Types.h"

 #include "USBDevice.h"

 /**
 * USBMSD class: generic class in order to use all kinds of blocks storage chip
 *
 * Introduction
 *
 * The USBMSD implements the MSD protocol. It permits to access a memory chip (flash, sdcard,...)
 * from a computer over USB. But this class doesn't work standalone, you need to subclass this class
 * and define virtual functions which are called in USBMSD.
 *
 * How to use this class with your chip ?
 *
 * You have to inherit and define some pure virtual functions (mandatory step):
 * - virtual int disk_read(char * data, int block): function to read a block
 * - virtual int disk_write(const char * data, int block): function to write a block
 * - virtual int disk_initialize(): function to initialize the memory
 * - virtual int disk_sectors(): return the number of blocks
 * - virtual int disk_size(): return the memory size
 * - virtual int disk_status(): return the status of the storage chip (0: OK, 1: not initialized, 2: no medium in the drive, 4: write protection)
 *
 * All functions names are compatible with the fat filesystem library. So you can imagine using your own class with
 * USBMSD and the fat filesystem library in the same program. Just be careful because there are two different parts which
 * will access the sd card. You can do a master/slave system using the disk_status method.
 *
 * Once these functions defined, you can call connect() (at the end of the constructor of your class for instance)
 * of USBMSD to connect your mass storage device. connect() will first call disk_status() to test the status of the disk.
 * If disk_status() returns 1 (disk not initialized), then disk_initialize() is called. After this step, connect() will collect information
 * such as the number of blocks and the memory size.
 */
 class USBMSD: public USBDevice {
 public:

 /**
 * Constructor
 *
 * @param vendor_id Your vendor_id
 * @param product_id Your product_id
 * @param product_release Your preoduct_release
 */
 USBMSD(uint16_t vendor_id = 0x0703, uint16_t product_id = 0x0104, uint16_t product_release = 0x0001);

 /**
 * Connect the USB MSD device. Establish disk initialization before really connect the device.
 *
 * @param blocking if not configured
 * @returns true if successful
 */
 bool connect(bool blocking = true);

 /**
 * Disconnect the USB MSD device.
 */
 void disconnect();

 /**
 * Destructor
 */
 ~USBMSD();

 protected:

 /*
 * read one or more blocks on a storage chip
 *
 * @param data pointer where will be stored read data
 * @param block starting block number
 * @param count number of blocks to read
 * @returns 0 if successful
 */
 virtual int disk_read(uint8_t* data, uint64_t block, uint8_t count) = 0;

 /*
 * write one or more blocks on a storage chip
 *
 * @param data data to write
 * @param block starting block number
 * @param count number of blocks to write
 * @returns 0 if successful
 */
 virtual int disk_write(const uint8_t* data, uint64_t block, uint8_t count) = 0;

 /*
 * Disk initilization
 */
 virtual int disk_initialize() = 0;

 /*
 * Return the number of blocks
 *
 * @returns number of blocks
 */
 virtual uint64_t disk_sectors() = 0;

 /*
 * Return memory size
 *
 * @returns memory size
 */
 virtual uint64_t disk_size() = 0;


 /*
 * To check the status of the storage chip
 *
 * @returns status: 0: OK, 1: disk not initialized, 2: no medium in the drive, 4: write protected
 */
 virtual int disk_status() = 0;

 /*
 * Get string product descriptor
 *
 * @returns pointer to the string product descriptor
 */
 virtual uint8_t * stringIproductDesc();

 /*
 * Get string interface descriptor
 *
 * @returns pointer to the string interface descriptor
 */
 virtual uint8_t * stringIinterfaceDesc();

 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();

 /*
 * Callback called when a packet is received
 */
 virtual bool EPBULK_OUT_callback();

 /*
 * Callback called when a packet has been sent
 */
 virtual bool EPBULK_IN_callback();

 /*
 * Set configuration of device. Add endpoints
 */
 virtual bool USBCallback_setConfiguration(uint8_t configuration);

 /*
 * Callback called to process class specific requests
 */
 virtual bool USBCallback_request();


 private:

 // MSC Bulk-only Stage
 enum Stage {
 READ_CBW, // wait a CBW
 ERROR, // error
 PROCESS_CBW, // process a CBW request
 SEND_CSW, // send a CSW
 WAIT_CSW, // wait that a CSW has been effectively sent
 };

 // Bulk-only CBW
 typedef struct {
 uint32_t Signature;
 uint32_t Tag;
 uint32_t DataLength;
 uint8_t Flags;
 uint8_t LUN;
 uint8_t CBLength;
 uint8_t CB[16];
 } PACKED CBW;

 // Bulk-only CSW
 typedef struct {
 uint32_t Signature;
 uint32_t Tag;
 uint32_t DataResidue;
 uint8_t Status;
 } PACKED CSW;

 //state of the bulk-only state machine
 Stage stage;

 // current CBW
 CBW cbw;

 // CSW which will be sent
 CSW csw;

 // addr where will be read or written data
 uint32_t addr;

 // length of a reading or writing
 uint32_t length;

 // memory OK (after a memoryVerify)
 bool memOK;

 // cache in RAM before writing in memory. Useful also to read a block.
 uint8_t * page;

 int BlockSize;
 uint64_t MemorySize;
 uint64_t BlockCount;

 void CBWDecode(uint8_t * buf, uint16_t size);
 void sendCSW (void);
 bool inquiryRequest (void);
 bool write (uint8_t * buf, uint16_t size);
 bool readFormatCapacity();
 bool readCapacity (void);
 bool infoTransfer (void);
 void memoryRead (void);
 bool modeSense6 (void);
 void testUnitReady (void);
 bool requestSense (void);
 void memoryVerify (uint8_t * buf, uint16_t size);
 void memoryWrite (uint8_t * buf, uint16_t size);
 void reset();
 void fail();
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/CircBuffer.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/CircBuffer.h
@@ -0,0 +1,63 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef CIRCBUFFER_H
 #define CIRCBUFFER_H

 template <class T, int Size>
 class CircBuffer {
 public:
 CircBuffer():write(0), read(0){}
 bool isFull() {
 return ((write + 1) % size == read);
 };

 bool isEmpty() {
 return (read == write);
 };

 void queue(T k) {
 if (isFull()) {
 read++;
 read %= size;
 }
 buf[write++] = k;
 write %= size;
 }

 uint16_t available() {
 return (write >= read) ? write - read : size - read + write;
 };

 bool dequeue(T * c) {
 bool empty = isEmpty();
 if (!empty) {
 *c = buf[read++];
 read %= size;
 }
 return(!empty);
 };

 private:
 volatile uint16_t write;
 volatile uint16_t read;
 static const int size = Size+1; //a modern optimizer should be able to remove this so it uses no ram.
 T buf[Size];
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.cpp
@@ -0,0 +1,286 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBCDC.h"

 static uint8_t cdc_line_coding[7]= {0x80, 0x25, 0x00, 0x00, 0x00, 0x00, 0x08};

 #define DEFAULT_CONFIGURATION (1)

 #define CDC_SET_LINE_CODING 0x20
 #define CDC_GET_LINE_CODING 0x21
 #define CDC_SET_CONTROL_LINE_STATE 0x22

 // Control Line State bits
 #define CLS_DTR (1 << 0)
 #define CLS_RTS (1 << 1)

 #define MAX_CDC_REPORT_SIZE MAX_PACKET_SIZE_EPBULK

 USBCDC::USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect_blocking): USBDevice(vendor_id, product_id, product_release) {
 terminal_connected = false;
 USBDevice::connect(connect_blocking);
 }

 bool USBCDC::USBCallback_request(void) {
 /* Called in ISR context */

 bool success = false;
 CONTROL_TRANSFER * transfer = getTransferPtr();

 /* Process class-specific requests */

 if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
 switch (transfer->setup.bRequest) {
 case CDC_GET_LINE_CODING:
 transfer->remaining = 7;
 transfer->ptr = cdc_line_coding;
 transfer->direction = DEVICE_TO_HOST;
 success = true;
 break;
 case CDC_SET_LINE_CODING:
 transfer->remaining = 7;
 transfer->notify = true;
 success = true;
 break;
 case CDC_SET_CONTROL_LINE_STATE:
 if (transfer->setup.wValue & CLS_DTR) {
 terminal_connected = true;
 } else {
 terminal_connected = false;
 }
 success = true;
 break;
 default:
 break;
 }
 }

 return success;
 }

 void USBCDC::USBCallback_requestCompleted(uint8_t *buf, uint32_t length) {
 // Request of setting line coding has 7 bytes
 if (length != 7) {
 return;
 }

 CONTROL_TRANSFER * transfer = getTransferPtr();

 /* Process class-specific requests */
 if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
 if (transfer->setup.bRequest == CDC_SET_LINE_CODING) {
 if (memcmp(cdc_line_coding, buf, 7)) {
 memcpy(cdc_line_coding, buf, 7);

 int baud = buf[0] + (buf[1] << 8)
 + (buf[2] << 16) + (buf[3] << 24);
 int stop = buf[4];
 int bits = buf[6];
 int parity = buf[5];

 lineCodingChanged(baud, bits, parity, stop);
 }
 }
 }
 }

 // Called in ISR context
 // Set configuration. Return false if the
 // configuration is not supported.
 bool USBCDC::USBCallback_setConfiguration(uint8_t configuration) {
 if (configuration != DEFAULT_CONFIGURATION) {
 return false;
 }

 // Configure endpoints > 0
 addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT);
 addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
 addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);

 // We activate the endpoint to be able to recceive data
 readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
 return true;
 }

 bool USBCDC::send(uint8_t * buffer, uint32_t size) {
 return USBDevice::write(EPBULK_IN, buffer, size, MAX_CDC_REPORT_SIZE);
 }

 bool USBCDC::readEP(uint8_t * buffer, uint32_t * size) {
 if (!USBDevice::readEP(EPBULK_OUT, buffer, size, MAX_CDC_REPORT_SIZE))
 return false;
 if (!readStart(EPBULK_OUT, MAX_CDC_REPORT_SIZE))
 return false;
 return true;
 }

 bool USBCDC::readEP_NB(uint8_t * buffer, uint32_t * size) {
 if (!USBDevice::readEP_NB(EPBULK_OUT, buffer, size, MAX_CDC_REPORT_SIZE))
 return false;
 if (!readStart(EPBULK_OUT, MAX_CDC_REPORT_SIZE))
 return false;
 return true;
 }


 uint8_t * USBCDC::deviceDesc() {
 static uint8_t deviceDescriptor[] = {
 18, // bLength
 1, // bDescriptorType
 0x10, 0x01, // bcdUSB
 2, // bDeviceClass
 0, // bDeviceSubClass
 0, // bDeviceProtocol
 MAX_PACKET_SIZE_EP0, // bMaxPacketSize0
 (uint8_t)(LSB(VENDOR_ID)), (uint8_t)(MSB(VENDOR_ID)), // idVendor
 (uint8_t)(LSB(PRODUCT_ID)), (uint8_t)(MSB(PRODUCT_ID)),// idProduct
 0x00, 0x01, // bcdDevice
 1, // iManufacturer
 2, // iProduct
 3, // iSerialNumber
 1 // bNumConfigurations
 };
 return deviceDescriptor;
 }

 uint8_t * USBCDC::stringIinterfaceDesc() {
 static uint8_t stringIinterfaceDescriptor[] = {
 0x08,
 STRING_DESCRIPTOR,
 'C',0,'D',0,'C',0,
 };
 return stringIinterfaceDescriptor;
 }

 uint8_t * USBCDC::stringIproductDesc() {
 static uint8_t stringIproductDescriptor[] = {
 0x16,
 STRING_DESCRIPTOR,
 'C',0,'D',0,'C',0,' ',0,'D',0,'E',0,'V',0,'I',0,'C',0,'E',0
 };
 return stringIproductDescriptor;
 }


 #define CONFIG1_DESC_SIZE (9+8+9+5+5+4+5+7+9+7+7)

 uint8_t * USBCDC::configurationDesc() {
 static uint8_t configDescriptor[] = {
 // configuration descriptor
 9, // bLength
 2, // bDescriptorType
 LSB(CONFIG1_DESC_SIZE), // wTotalLength
 MSB(CONFIG1_DESC_SIZE),
 2, // bNumInterfaces
 1, // bConfigurationValue
 0, // iConfiguration
 0x80, // bmAttributes
 50, // bMaxPower

 // IAD to associate the two CDC interfaces
 0x08, // bLength
 0x0b, // bDescriptorType
 0x00, // bFirstInterface
 0x02, // bInterfaceCount
 0x02, // bFunctionClass
 0x02, // bFunctionSubClass
 0, // bFunctionProtocol
 0, // iFunction

 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 9, // bLength
 4, // bDescriptorType
 0, // bInterfaceNumber
 0, // bAlternateSetting
 1, // bNumEndpoints
 0x02, // bInterfaceClass
 0x02, // bInterfaceSubClass
 0x01, // bInterfaceProtocol
 0, // iInterface

 // CDC Header Functional Descriptor, CDC Spec 5.2.3.1, Table 26
 5, // bFunctionLength
 0x24, // bDescriptorType
 0x00, // bDescriptorSubtype
 0x10, 0x01, // bcdCDC

 // Call Management Functional Descriptor, CDC Spec 5.2.3.2, Table 27
 5, // bFunctionLength
 0x24, // bDescriptorType
 0x01, // bDescriptorSubtype
 0x03, // bmCapabilities
 1, // bDataInterface

 // Abstract Control Management Functional Descriptor, CDC Spec 5.2.3.3, Table 28
 4, // bFunctionLength
 0x24, // bDescriptorType
 0x02, // bDescriptorSubtype
 0x06, // bmCapabilities

 // Union Functional Descriptor, CDC Spec 5.2.3.8, Table 33
 5, // bFunctionLength
 0x24, // bDescriptorType
 0x06, // bDescriptorSubtype
 0, // bMasterInterface
 1, // bSlaveInterface0

 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPINT_IN), // bEndpointAddress
 E_INTERRUPT, // bmAttributes (0x03=intr)
 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
 16, // bInterval




 // interface descriptor, USB spec 9.6.5, page 267-269, Table 9-12
 9, // bLength
 4, // bDescriptorType
 1, // bInterfaceNumber
 0, // bAlternateSetting
 2, // bNumEndpoints
 0x0A, // bInterfaceClass
 0x00, // bInterfaceSubClass
 0x00, // bInterfaceProtocol
 0, // iInterface

 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPBULK_IN), // bEndpointAddress
 E_BULK, // bmAttributes (0x02=bulk)
 LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB)
 0, // bInterval

 // endpoint descriptor, USB spec 9.6.6, page 269-271, Table 9-13
 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
 ENDPOINT_DESCRIPTOR, // bDescriptorType
 PHY_TO_DESC(EPBULK_OUT), // bEndpointAddress
 E_BULK, // bmAttributes (0x02=bulk)
 LSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (LSB)
 MSB(MAX_PACKET_SIZE_EPBULK),// wMaxPacketSize (MSB)
 0 // bInterval
 };
 return configDescriptor;
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBCDC.h
@@ -0,0 +1,123 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBCDC_H
 #define USBCDC_H

 /* These headers are included for child class. */
 #include "USBEndpoints.h"
 #include "USBDescriptor.h"
 #include "USBDevice_Types.h"

 #include "USBDevice.h"

 class USBCDC: public USBDevice {
 public:

 /*
 * Constructor
 *
 * @param vendor_id Your vendor_id
 * @param product_id Your product_id
 * @param product_release Your preoduct_release
 * @param connect_blocking define if the connection must be blocked if USB not plugged in
 */
 USBCDC(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, bool connect_blocking);

 protected:

 /*
 * Get device descriptor. Warning: this method has to store the length of the report descriptor in reportLength.
 *
 * @returns pointer to the device descriptor
 */
 virtual uint8_t * deviceDesc();

 /*
 * Get string product descriptor
 *
 * @returns pointer to the string product descriptor
 */
 virtual uint8_t * stringIproductDesc();

 /*
 * Get string interface descriptor
 *
 * @returns pointer to the string interface descriptor
 */
 virtual uint8_t * stringIinterfaceDesc();

 /*
 * Get configuration descriptor
 *
 * @returns pointer to the configuration descriptor
 */
 virtual uint8_t * configurationDesc();

 /*
 * Send a buffer
 *
 * @param endpoint endpoint which will be sent the buffer
 * @param buffer buffer to be sent
 * @param size length of the buffer
 * @returns true if successful
 */
 bool send(uint8_t * buffer, uint32_t size);

 /*
 * Read a buffer from a certain endpoint. Warning: blocking
 *
 * @param endpoint endpoint to read
 * @param buffer buffer where will be stored bytes
 * @param size the number of bytes read will be stored in *size
 * @param maxSize the maximum length that can be read
 * @returns true if successful
 */
 bool readEP(uint8_t * buffer, uint32_t * size);

 /*
 * Read a buffer from a certain endpoint. Warning: non blocking
 *
 * @param endpoint endpoint to read
 * @param buffer buffer where will be stored bytes
 * @param size the number of bytes read will be stored in *size
 * @param maxSize the maximum length that can be read
 * @returns true if successful
 */
 bool readEP_NB(uint8_t * buffer, uint32_t * size);

 /*
 * Called by USBCallback_requestCompleted when CDC line coding is changed
 * Warning: Called in ISR
 *
 * @param baud The baud rate
 * @param bits The number of bits in a word (5-8)
 * @param parity The parity
 * @param stop The number of stop bits (1 or 2)
 */
 virtual void lineCodingChanged(int baud, int bits, int parity, int stop) {};

 protected:
 virtual bool USBCallback_request();
 virtual void USBCallback_requestCompleted(uint8_t *buf, uint32_t length);
 virtual bool USBCallback_setConfiguration(uint8_t configuration);
 volatile bool terminal_connected;

 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.cpp
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.cpp
@@ -0,0 +1,67 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #include "stdint.h"
 #include "USBSerial.h"

 int USBSerial::_putc(int c) {
 if (!terminal_connected)
 return 0;
 send((uint8_t *)&c, 1);
 return 1;
 }

 int USBSerial::_getc() {
 uint8_t c = 0;
 while (buf.isEmpty());
 buf.dequeue(&c);
 return c;
 }


 bool USBSerial::writeBlock(uint8_t * buf, uint16_t size) {
 if(size > MAX_PACKET_SIZE_EPBULK) {
 return false;
 }
 if(!send(buf, size)) {
 return false;
 }
 return true;
 }



 bool USBSerial::EPBULK_OUT_callback() {
 uint8_t c[65];
 uint32_t size = 0;

 //we read the packet received and put it on the circular buffer
 readEP(c, &size);
 for (uint32_t i = 0; i < size; i++) {
 buf.queue(c[i]);
 }

 //call a potential handler
 rx.call();

 return true;
 }

 uint8_t USBSerial::available() {
 return buf.available();
 }
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBDevice/USBSerial/USBSerial.h
@@ -0,0 +1,161 @@
 /* Copyright (c) 2010-2011 mbed.org, MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

 #ifndef USBSERIAL_H
 #define USBSERIAL_H

 #include "USBCDC.h"
 #include "Stream.h"
 #include "CircBuffer.h"


 /**
 * USBSerial example
 *
 * @code
 * #include "mbed.h"
 * #include "USBSerial.h"
 *
 * //Virtual serial port over USB
 * USBSerial serial;
 *
 * int main(void) {
 *
 * while(1)
 * {
 * serial.printf("I am a virtual serial port\n");
 * wait(1);
 * }
 * }
 * @endcode
 */
 class USBSerial: public USBCDC, public Stream {
 public:

 /**
 * Constructor
 *
 * @param vendor_id Your vendor_id (default: 0x1f00)
 * @param product_id Your product_id (default: 0x2012)
 * @param product_release Your preoduct_release (default: 0x0001)
 * @param connect_blocking define if the connection must be blocked if USB not plugged in
 *
 */
 USBSerial(uint16_t vendor_id = 0x1f00, uint16_t product_id = 0x2012, uint16_t product_release = 0x0001, bool connect_blocking = true): USBCDC(vendor_id, product_id, product_release, connect_blocking){
 settingsChangedCallback = 0;
 };


 /**
 * Send a character. You can use puts, printf.
 *
 * @param c character to be sent
 * @returns true if there is no error, false otherwise
 */
 virtual int _putc(int c);

 /**
 * Read a character: blocking
 *
 * @returns character read
 */
 virtual int _getc();

 /**
 * Check the number of bytes available.
 *
 * @returns the number of bytes available
 */
 uint8_t available();

 /** Determine if there is a character available to read
 *
 * @returns
 * 1 if there is a character available to read,
 * 0 otherwise
 */
 int readable() { return available() ? 1 : 0; }

 /** Determine if there is space available to write a character
 *
 * @returns
 * 1 if there is space to write a character,
 * 0 otherwise
 */
 int writeable() { return 1; } // always return 1, for write operation is blocking

 /**
 * Write a block of data.
 *
 * For more efficiency, a block of size 64 (maximum size of a bulk endpoint) has to be written.
 *
 * @param buf pointer on data which will be written
 * @param size size of the buffer. The maximum size of a block is limited by the size of the endpoint (64 bytes)
 *
 * @returns true if successfull
 */
 bool writeBlock(uint8_t * buf, uint16_t size);

 /**
 * Attach a member function to call when a packet is received.
 *
 * @param tptr pointer to the object to call the member function on
 * @param mptr pointer to the member function to be called
 */
 template<typename T>
 void attach(T* tptr, void (T::*mptr)(void)) {
 if((mptr != NULL) && (tptr != NULL)) {
 rx.attach(tptr, mptr);
 }
 }

 /**
 * Attach a callback called when a packet is received
 *
 * @param fptr function pointer
 */
 void attach(void (*fptr)(void)) {
 if(fptr != NULL) {
 rx.attach(fptr);
 }
 }

 /**
 * Attach a callback to call when serial's settings are changed.
 *
 * @param fptr function pointer
 */
 void attach(void (*fptr)(int baud, int bits, int parity, int stop)) {
 settingsChangedCallback = fptr;
 }

 protected:
 virtual bool EPBULK_OUT_callback();
 virtual void lineCodingChanged(int baud, int bits, int parity, int stop){
 if (settingsChangedCallback) {
 settingsChangedCallback(baud, bits, parity, stop);
 }
 }

 private:
 FunctionPointer rx;
 CircBuffer<uint8_t,128> buf;
 void (*settingsChangedCallback)(int baud, int bits, int parity, int stop);
 };

 #endif
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/IUSBEnumerator.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/IUSBEnumerator.h
@@ -0,0 +1,36 @@
 /* mbed USBHost Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 *
 * 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 IUSBENUMERATOR_H_
 #define IUSBENUMERATOR_H_

 #include "stdint.h"
 #include "USBEndpoint.h"

 /*
 Generic interface to implement for "smart" USB enumeration
 */

 class IUSBEnumerator
 {
 public:
 virtual void setVidPid(uint16_t vid, uint16_t pid) = 0;
 virtual bool parseInterface(uint8_t intf_nb, uint8_t intf_class, uint8_t intf_subclass, uint8_t intf_protocol) = 0; //Must return true if the interface should be parsed
 virtual bool useEndpoint(uint8_t intf_nb, ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir) = 0; //Must return true if the endpoint will be used
 };

 #endif /*IUSBENUMERATOR_H_*/

--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_host_api.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/inc/devdrv_usb_host_api.h
@@ -0,0 +1,329 @@
 /*******************************************************************************
 * 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_host_api.h
 * $Rev: 1116 $
 * $Date:: 2014-07-09 16:29:19 +0900#$
 * Description : RZ/A1H R7S72100 USB Sample Program
 *******************************************************************************/
 #ifndef USB_HOST_API_H
 #define USB_HOST_API_H

 #include "r_typedefs.h"


 /*******************************************************************************
 Typedef definitions
 *******************************************************************************/


 /*******************************************************************************
 Macro definitions
 *******************************************************************************/
 #define USB_HOST_PORTNUM (2)

 #define USB_HOST_ELT_INTERRUPT_LEVEL (9)

 #define USBHCLOCK_X1_48MHZ (0x0000u) /* USB_X1_48MHz */
 #define USBHCLOCK_EXTAL_12MHZ (0x0004u) /* EXTAL_12MHz */

 #define USB_HOST_MAX_DEVICE (10)

 #define USB_HOST_ON (1)
 #define USB_HOST_OFF (0)
 #define USB_HOST_YES (1)
 #define USB_HOST_NO (0)

 #define USB_HOST_NON_SPEED (0)
 #define USB_HOST_LOW_SPEED (1)
 #define USB_HOST_FULL_SPEED (2)
 #define USB_HOST_HIGH_SPEED (3)

 /* DEVDRV_SUCCESS(0) & DEVDRV_ERROR(-1) is dev_drv.h */
 #define DEVDRV_USBH_STALL (-2)
 #define DEVDRV_USBH_TIMEOUT (-3)
 #define DEVDRV_USBH_NAK_TIMEOUT (-4)
 #define DEVDRV_USBH_DETACH_ERR (-5)
 #define DEVDRV_USBH_SETUP_ERR (-6)
 #define DEVDRV_USBH_CTRL_COM_ERR (-7)
 #define DEVDRV_USBH_COM_ERR (-8)
 #define DEVDRV_USBH_DEV_ADDR_ERR (-9)

 #define USB_HOST_ATTACH (1)
 #define USB_HOST_DETACH (0)

 #define USB_HOST_MAX_PIPE_NO (9u)
 #define USB_HOST_PIPE0 (0)
 #define USB_HOST_PIPE1 (1)
 #define USB_HOST_PIPE2 (2)
 #define USB_HOST_PIPE3 (3)
 #define USB_HOST_PIPE4 (4)
 #define USB_HOST_PIPE5 (5)
 #define USB_HOST_PIPE6 (6)
 #define USB_HOST_PIPE7 (7)
 #define USB_HOST_PIPE8 (8)
 #define USB_HOST_PIPE9 (9)

 #define USB_HOST_ISO (0xc000u)
 #define USB_HOST_INTERRUPT (0x8000u)
 #define USB_HOST_BULK (0x4000u)

 #define USB_HOST_PIPE_IDLE (0x00)
 #define USB_HOST_PIPE_WAIT (0x01)
 #define USB_HOST_PIPE_DONE (0x02)
 #define USB_HOST_PIPE_NORES (0x03)
 #define USB_HOST_PIPE_STALL (0x04)
 #define USB_HOST_PIPE_ERROR (0x05)

 #define USB_HOST_NONE (0x0000u)
 #define USB_HOST_BFREFIELD (0x0400u)
 #define USB_HOST_BFREON (0x0400u)
 #define USB_HOST_BFREOFF (0x0000u)
 #define USB_HOST_DBLBFIELD (0x0200u)
 #define USB_HOST_DBLBON (0x0200u)
 #define USB_HOST_DBLBOFF (0x0000u)
 #define USB_HOST_CNTMDFIELD (0x0100u)
 #define USB_HOST_CNTMDON (0x0100u)
 #define USB_HOST_CNTMDOFF (0x0000u)
 #define USB_HOST_SHTNAKON (0x0080u)
 #define USB_HOST_SHTNAKOFF (0x0000u)
 #define USB_HOST_DIRFIELD (0x0010u)
 #define USB_HOST_DIR_H_OUT (0x0010u)
 #define USB_HOST_DIR_H_IN (0x0000u)
 #define USB_HOST_EPNUMFIELD (0x000fu)

 #define USB_HOST_CUSE (0)
 #define USB_HOST_D0USE (1)
 #define USB_HOST_D0DMA (2)
 #define USB_HOST_D1USE (3)
 #define USB_HOST_D1DMA (4)

 #define USB_HOST_CFIFO_USE (0x0000)
 #define USB_HOST_D0FIFO_USE (0x1000)
 #define USB_HOST_D1FIFO_USE (0x2000)
 #define USB_HOST_D0FIFO_DMA (0x5000)
 #define USB_HOST_D1FIFO_DMA (0x6000)

 #define USB_HOST_BUF2FIFO (0)
 #define USB_HOST_FIFO2BUF (1)

 #define USB_HOST_DRV_DETACHED (0x0000)
 #define USB_HOST_DRV_ATTACHED (0x0001)
 #define USB_HOST_DRV_GET_DEVICE_DESC_64 (0x0002)
 #define USB_HOST_DRV_POWERED (0x0003)
 #define USB_HOST_DRV_DEFAULT (0x0004)
 #define USB_HOST_DRV_SET_ADDRESS (0x0005)
 #define USB_HOST_DRV_ADDRESSED (0x0006)
 #define USB_HOST_DRV_GET_DEVICE_DESC_18 (0x0007)
 #define USB_HOST_DRV_GET_CONGIG_DESC_9 (0x0008)
 #define USB_HOST_DRV_GET_CONGIG_DESC (0x0009)
 #define USB_HOST_DRV_SET_CONFIG (0x000a)
 #define USB_HOST_DRV_CONFIGURED (0x000b)
 #define USB_HOST_DRV_SUSPEND (0x1000)
 #define USB_HOST_DRV_NORES (0x0100)
 #define USB_HOST_DRV_STALL (0x0200)

 #define USB_HOST_TESTMODE_FORCE (0x000du)
 #define USB_HOST_TESTMODE_TESTPACKET (0x000cu)
 #define USB_HOST_TESTMODE_SE0_NAK (0x000bu)
 #define USB_HOST_TESTMODE_K (0x000au)
 #define USB_HOST_TESTMODE_J (0x0009u)
 #define USB_HOST_TESTMODE_NORMAL (0x0000u)

 #define USB_HOST_DT_DEVICE (0x01)
 #define USB_HOST_DT_CONFIGURATION (0x02)
 #define USB_HOST_DT_STRING (0x03)
 #define USB_HOST_DT_INTERFACE (0x04)
 #define USB_HOST_DT_ENDPOINT (0x05)
 #define USB_HOST_DT_DEVICE_QUALIFIER (0x06)
 #define USB_HOST_DT_OTHER_SPEED_CONFIGURATION (0x07)
 #define USB_HOST_DT_INTERFACE_POWER (0x08)

 #define USB_HOST_IF_CLS_NOT (0x00)
 #define USB_HOST_IF_CLS_AUDIO (0x01)
 #define USB_HOST_IF_CLS_CDC_CTRL (0x02)
 #define USB_HOST_IF_CLS_HID (0x03)
 #define USB_HOST_IF_CLS_PHYSICAL (0x05)
 #define USB_HOST_IF_CLS_IMAGE (0x06)
 #define USB_HOST_IF_CLS_PRINTER (0x07)
 #define USB_HOST_IF_CLS_MASS (0x08)
 #define USB_HOST_IF_CLS_HUB (0x09)
 #define USB_HOST_IF_CLS_CDC_DATA (0x0a)
 #define USB_HOST_IF_CLS_CRAD (0x0b)
 #define USB_HOST_IF_CLS_CONTENT (0x0d)
 #define USB_HOST_IF_CLS_VIDEO (0x0e)
 #define USB_HOST_IF_CLS_DIAG (0xdc)
 #define USB_HOST_IF_CLS_WIRELESS (0xe0)
 #define USB_HOST_IF_CLS_APL (0xfe)
 #define USB_HOST_IF_CLS_VENDOR (0xff)
 #define USB_HOST_IF_CLS_HELE (0xaa)

 #define USB_HOST_EP_DIR_MASK (0x80)
 #define USB_HOST_EP_OUT (0x00)
 #define USB_HOST_EP_IN (0x80)
 #define USB_HOST_EP_TYPE (0x03)
 #define USB_HOST_EP_CNTRL (0x00)
 #define USB_HOST_EP_ISO (0x01)
 #define USB_HOST_EP_BULK (0x02)
 #define USB_HOST_EP_INT (0x03)
 #define USB_HOST_EP_NUM_MASK (0x0f)

 #define USB_HOST_PIPE_IN (0)
 #define USB_HOST_PIPE_OUT (1)

 #define USB_END_POINT_ERROR (0xffff)

 #define USB_HOST_REQ_GET_STATUS (0x0000)
 #define USB_HOST_REQ_CLEAR_FEATURE (0x0100)
 #define USB_HOST_REQ_RESERVED2 (0x0200)
 #define USB_HOST_REQ_SET_FEATURE (0x0300)
 #define USB_HOST_REQ_RESERVED4 (0x0400)
 #define USB_HOST_REQ_SET_ADDRESS (0x0500)
 #define USB_HOST_REQ_GET_DESCRIPTOR (0x0600)
 #define USB_HOST_REQ_SET_DESCRIPTOR (0x0700)
 #define USB_HOST_REQ_GET_CONFIGURATION (0x0800)
 #define USB_HOST_REQ_SET_CONFIGURATION (0x0900)
 #define USB_HOST_REQ_GET_INTERFACE (0x0a00)
 #define USB_HOST_REQ_SET_INTERFACE (0x0b00)
 #define USB_HOST_REQ_SYNCH_FRAME (0x0c00)

 #define USB_HOST_REQTYPE_HOST_TO_DEVICE (0x0000)
 #define USB_HOST_REQTYPE_DEVICE_TO_HOST (0x0080)
 #define USB_HOST_REQTYPE_STANDARD (0x0020)
 #define USB_HOST_REQTYPE_CLASS (0x0040)
 #define USB_HOST_REQTYPE_VENDOR (0x0060)
 #define USB_HOST_REQTYPE_DEVICE (0x0000)
 #define USB_HOST_REQTYPE_INTERFACE (0x0001)
 #define USB_HOST_REQTYPE_ENDPOINT (0x0002)
 #define USB_HOST_REQTYPE_OTHER (0x0003)

 #define USB_HOST_DESCTYPE_DEVICE (0x0100)
 #define USB_HOST_DESCTYPE_CONFIGURATION (0x0200)
 #define USB_HOST_DESCTYPE_STRING (0x0300)
 #define USB_HOST_DESCTYPE_INTERFACE (0x0400)
 #define USB_HOST_DESCTYPE_ENDPOINT (0x0500)
 #define USB_HOST_DESCTYPE_DEVICE_QUALIFIER (0x0600)
 #define USB_HOST_DESCTYPE_OTHER_SPEED_CONFIGURATION (0x0700)
 #define USB_HOST_DESCTYPE_INTERFACE_POWER (0x0800)


 /*******************************************************************************
 Variable Externs
 *******************************************************************************/
 typedef struct
 {
 uint16_t pipe_number;
 uint16_t pipe_cfg;
 uint16_t pipe_buf;
 uint16_t pipe_max_pktsize;
 uint16_t pipe_cycle;
 uint16_t fifo_port;
 } USB_HOST_CFG_PIPETBL_t;

 typedef struct
 {
 uint32_t fifo;
 uint32_t buffer;
 uint32_t bytes;
 uint32_t dir;
 uint32_t size;
 } USB_HOST_DMA_t;


 /*******************************************************************************
 Imported global variables and functions (from other files)
 *******************************************************************************/
 uint16_t R_USB_api_host_init(uint16_t root, uint8_t int_level, uint16_t mode, uint16_t clockmode);
 int32_t R_USB_api_host_enumeration(uint16_t root, uint16_t devadr);
 int32_t R_USB_api_host_detach(uint16_t root);
 int32_t R_USB_api_host_data_in(uint16_t root, uint16_t devadr, uint16_t Pipe, uint32_t Size, uint8_t *data_buf);
 int32_t R_USB_api_host_data_in2(uint16_t root, uint16_t devadr, uint16_t Pipe, uint32_t Size, uint8_t *data_buf, uint32_t *bytes);
 int32_t R_USB_api_host_data_out(uint16_t root, uint16_t devadr, uint16_t Pipe, uint32_t Size, uint8_t *data_buf);
 int32_t R_USB_api_host_control_transfer(uint16_t root, uint16_t devadr, uint16_t Req, uint16_t Val, uint16_t Indx, uint16_t Len, uint8_t *Buf);
 int32_t R_USB_api_host_set_endpoint(uint16_t root, uint16_t devadr, USB_HOST_CFG_PIPETBL_t *user_table, uint8_t *configdescriptor);
 int32_t R_USB_api_host_clear_endpoint(uint16_t root, USB_HOST_CFG_PIPETBL_t *user_table);
 int32_t R_USB_api_host_clear_endpoint_pipe(uint16_t root, uint16_t pipe_sel, USB_HOST_CFG_PIPETBL_t *user_table);
 uint16_t R_USB_api_host_SetEndpointTable(uint16_t root, uint16_t devadr, USB_HOST_CFG_PIPETBL_t *user_table, uint8_t* Table);

 int32_t R_USB_api_host_GetDeviceDescriptor(uint16_t root, uint16_t devadr, uint16_t size, uint8_t *buf);
 int32_t R_USB_api_host_GetConfigDescriptor(uint16_t root, uint16_t devadr, uint16_t size, uint8_t *buf);
 int32_t R_USB_api_host_SetConfig(uint16_t root, uint16_t devadr, uint16_t confignum);
 int32_t R_USB_api_host_SetInterface(uint16_t root, uint16_t devadr, uint16_t interface_alt, uint16_t interface_index);
 int32_t R_USB_api_host_ClearStall(uint16_t root, uint16_t devadr, uint16_t ep_dir);
 uint16_t R_USB_api_host_GetUsbDeviceState(uint16_t root);

 void R_USB_api_host_elt_clocksel(uint16_t clockmode);
 void R_USB_api_host_elt_4_4(uint16_t root);
 void R_USB_api_host_elt_4_5(uint16_t root);
 void R_USB_api_host_elt_4_6(uint16_t root);
 void R_USB_api_host_elt_4_7(uint16_t root);
 void R_USB_api_host_elt_4_8(uint16_t root);
 void R_USB_api_host_elt_4_9(uint16_t root);
 void R_USB_api_host_elt_get_desc(uint16_t root);


 /*******************************************************************************
 Includes <System Includes> , "Project Includes"
 *******************************************************************************/
 #include "usb0_host_api.h"
 #include "usb1_host_api.h"


 /*******************************************************************************
 Imported global variables and functions (from other files)
 *******************************************************************************/
 #ifdef USB0_HOST_API_H
 uint16_t Userdef_USB_usb0_host_d0fifo_dmaintid(void);
 uint16_t Userdef_USB_usb0_host_d1fifo_dmaintid(void);
 void Userdef_USB_usb0_host_attach(void);
 void Userdef_USB_usb0_host_detach(void);
 void Userdef_USB_usb0_host_delay_1ms(void);
 void Userdef_USB_usb0_host_delay_xms(uint32_t msec);
 void Userdef_USB_usb0_host_delay_10us(uint32_t usec);
 void Userdef_USB_usb0_host_delay_500ns(void);
 void Userdef_USB_usb0_host_start_dma(USB_HOST_DMA_t * dma, uint16_t dfacc);
 uint32_t Userdef_USB_usb0_host_stop_dma0(void);
 uint32_t Userdef_USB_usb0_host_stop_dma1(void);
 void Userdef_USB_usb0_host_notice(const char * format);
 void Userdef_USB_usb0_host_user_rdy(const char * format, uint16_t data);
 #endif

 #ifdef USB1_HOST_API_H
 uint16_t Userdef_USB_usb1_host_d0fifo_dmaintid(void);
 uint16_t Userdef_USB_usb1_host_d1fifo_dmaintid(void);
 void Userdef_USB_usb1_host_attach(void);
 void Userdef_USB_usb1_host_detach(void);
 void Userdef_USB_usb1_host_delay_1ms(void);
 void Userdef_USB_usb1_host_delay_xms(uint32_t msec);
 void Userdef_USB_usb1_host_delay_10us(uint32_t usec);
 void Userdef_USB_usb1_host_delay_500ns(void);
 void Userdef_USB_usb1_host_start_dma(USB_HOST_DMA_t * dma, uint16_t dfacc);
 uint32_t Userdef_USB_usb1_host_stop_dma0(void);
 uint32_t Userdef_USB_usb1_host_stop_dma1(void);
 void Userdef_USB_usb1_host_notice(const char * format);
 void Userdef_USB_usb1_host_user_rdy(const char * format, uint16_t data);
 #endif

 #endif /* USB_HOST_API_H */

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_host.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/inc/usb_host.h
@@ -0,0 +1,201 @@
 /*******************************************************************************
 * 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_host.h
 * $Rev: 1116 $
 * $Date:: 2014-07-09 16:29:19 +0900#$
 * Description : RZ/A1H R7S72100 USB Sample Program
 *******************************************************************************/
 #ifndef USB_HOST_H
 #define USB_HOST_H


 /*******************************************************************************
 Includes <System Includes> , "Project Includes"
 *******************************************************************************/
 #include "r_typedefs.h"
 #include "iodefine.h"
 #include "rza_io_regrw.h"


 /*******************************************************************************
 Typedef definitions
 *******************************************************************************/


 /*******************************************************************************
 Macro definitions
 *******************************************************************************/
 #define USB_HOST_DEVICE_0 (0u)
 #define USB_HOST_DEVICE_1 (1u)
 #define USB_HOST_DEVICE_2 (2u)
 #define USB_HOST_DEVICE_3 (3u)
 #define USB_HOST_DEVICE_4 (4u)
 #define USB_HOST_DEVICE_5 (5u)
 #define USB_HOST_DEVICE_6 (6u)
 #define USB_HOST_DEVICE_7 (7u)
 #define USB_HOST_DEVICE_8 (8u)
 #define USB_HOST_DEVICE_9 (9u)
 #define USB_HOST_DEVICE_10 (10u)

 #define USB_HOST_ENDPOINT_DESC (0x05)

 #define USB_HOST_BITUPLLE (0x0002u)
 #define USB_HOST_BITUCKSEL (0x0004u)
 #define USB_HOST_BITBWAIT (0x003fu)

 #define USB_HOST_BUSWAIT_02 (0x0000u)
 #define USB_HOST_BUSWAIT_03 (0x0001u)
 #define USB_HOST_BUSWAIT_04 (0x0002u)
 #define USB_HOST_BUSWAIT_05 (0x0003u)
 #define USB_HOST_BUSWAIT_06 (0x0004u)
 #define USB_HOST_BUSWAIT_07 (0x0005u)
 #define USB_HOST_BUSWAIT_08 (0x0006u)
 #define USB_HOST_BUSWAIT_09 (0x0007u)
 #define USB_HOST_BUSWAIT_10 (0x0008u)
 #define USB_HOST_BUSWAIT_11 (0x0009u)
 #define USB_HOST_BUSWAIT_12 (0x000au)
 #define USB_HOST_BUSWAIT_13 (0x000bu)
 #define USB_HOST_BUSWAIT_14 (0x000cu)
 #define USB_HOST_BUSWAIT_15 (0x000du)
 #define USB_HOST_BUSWAIT_16 (0x000eu)
 #define USB_HOST_BUSWAIT_17 (0x000fu)

 #define USB_HOST_FS_JSTS (0x0001u)
 #define USB_HOST_LS_JSTS (0x0002u)

 #define USB_HOST_BITRST (0x0040u)
 #define USB_HOST_BITRESUME (0x0020u)
 #define USB_HOST_BITUACT (0x0010u)
 #define USB_HOST_HSPROC (0x0004u)
 #define USB_HOST_HSMODE (0x0003u)
 #define USB_HOST_FSMODE (0x0002u)
 #define USB_HOST_LSMODE (0x0001u)
 #define USB_HOST_UNDECID (0x0000u)

 #define USB_HOST_BITRCNT (0x8000u)
 #define USB_HOST_BITDREQE (0x1000u)
 #define USB_HOST_BITMBW (0x0c00u)
 #define USB_HOST_BITMBW_8 (0x0000u)
 #define USB_HOST_BITMBW_16 (0x0400u)
 #define USB_HOST_BITMBW_32 (0x0800u)
 #define USB_HOST_BITBYTE_LITTLE (0x0000u)
 #define USB_HOST_BITBYTE_BIG (0x0100u)
 #define USB_HOST_BITISEL (0x0020u)
 #define USB_HOST_BITCURPIPE (0x000fu)

 #define USB_HOST_CFIFO_READ (0x0000u)
 #define USB_HOST_CFIFO_WRITE (0x0020u)

 #define USB_HOST_BITBVAL (0x8000u)
 #define USB_HOST_BITBCLR (0x4000u)
 #define USB_HOST_BITFRDY (0x2000u)
 #define USB_HOST_BITDTLN (0x0fffu)

 #define USB_HOST_BITBEMPE (0x0400u)
 #define USB_HOST_BITNRDYE (0x0200u)
 #define USB_HOST_BITBRDYE (0x0100u)
 #define USB_HOST_BITBEMP (0x0400u)
 #define USB_HOST_BITNRDY (0x0200u)
 #define USB_HOST_BITBRDY (0x0100u)

 #define USB_HOST_BITBCHGE (0x4000u)
 #define USB_HOST_BITDTCHE (0x1000u)
 #define USB_HOST_BITATTCHE (0x0800u)
 #define USB_HOST_BITEOFERRE (0x0040u)
 #define USB_HOST_BITBCHG (0x4000u)
 #define USB_HOST_BITDTCH (0x1000u)
 #define USB_HOST_BITATTCH (0x0800u)
 #define USB_HOST_BITEOFERR (0x0040u)

 #define USB_HOST_BITSIGNE (0x0020u)
 #define USB_HOST_BITSACKE (0x0010u)
 #define USB_HOST_BITSIGN (0x0020u)
 #define USB_HOST_BITSACK (0x0010u)

 #define USB_HOST_BITSUREQ (0x4000u)
 #define USB_HOST_BITSQSET (0x0080u)
 #define USB_HOST_PID_STALL2 (0x0003u)
 #define USB_HOST_PID_STALL (0x0002u)
 #define USB_HOST_PID_BUF (0x0001u)
 #define USB_HOST_PID_NAK (0x0000u)

 #define USB_HOST_PIPExBUF (64u)

 #define USB_HOST_D0FIFO (0)
 #define USB_HOST_D1FIFO (1)
 #define USB_HOST_DMA_READY (0)
 #define USB_HOST_DMA_BUSY (1)
 #define USB_HOST_DMA_BUSYEND (2)

 #define USB_HOST_FIFO_USE (0x7000)

 #define USB_HOST_FIFOERROR (0xffff)
 #define USB_HOST_WRITEEND (0)
 #define USB_HOST_WRITESHRT (1)
 #define USB_HOST_WRITING (2)
 #define USB_HOST_WRITEDMA (3)
 #define USB_HOST_READEND (0)
 #define USB_HOST_READSHRT (1)
 #define USB_HOST_READING (2)
 #define USB_HOST_READOVER (3)
 #define USB_HOST_READZERO (4)

 #define USB_HOST_CMD_IDLE (0x0000)
 #define USB_HOST_CMD_DOING (0x0001)
 #define USB_HOST_CMD_DONE (0x0002)
 #define USB_HOST_CMD_NORES (0x0003)
 #define USB_HOST_CMD_STALL (0x0004)
 #define USB_HOST_CMD_FIELD (0x000f)

 #if 0
 #define USB_HOST_CHG_CMDFIELD( r, v ) do { r &= ( ~USB_HOST_CMD_FIELD ); \
 r |= v; } while(0)
 #endif

 #define USB_HOST_MODE_WRITE (0x0100)
 #define USB_HOST_MODE_READ (0x0200)
 #define USB_HOST_MODE_NO_DATA (0x0300)
 #define USB_HOST_MODE_FIELD (0x0f00)

 #define USB_HOST_STAGE_SETUP (0x0010)
 #define USB_HOST_STAGE_DATA (0x0020)
 #define USB_HOST_STAGE_STATUS (0x0030)
 #define USB_HOST_STAGE_FIELD (0x00f0)

 #if 0
 #define USB_HOST_CHG_STAGEFIELD( r, v ) do { r &= ( ~USB_HOST_STAGE_FIELD ); \
 r |= v; } while(0)
 #endif

 #define USB_HOST_DEVADD_MASK (0x7fc0)


 /*******************************************************************************
 Imported global variables and functions (from other files)
 *******************************************************************************/
 extern uint16_t g_usb_host_elt_clockmode;

 #endif /* USB_HOST_H */

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

 #define USB_HOST_LOCAL_Rev "VER080_140709"

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_RZ_A1.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_RZ_A1.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_RZ_A1.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_RZ_A1.h
@@ -0,0 +1,60 @@
 /* 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 OHCI_WRAPP_RZ_A1_H
 #define OHCI_WRAPP_RZ_A1_H

 #ifdef __cplusplus
 extern "C" {
 #endif

 #define OHCI_REG_REVISION (0x00) /* HcRevision */
 #define OHCI_REG_CONTROL (0x04) /* HcControl */
 #define OHCI_REG_COMMANDSTATUS (0x08) /* HcCommandStatus */
 #define OHCI_REG_INTERRUPTSTATUS (0x0C) /* HcInterruptStatus */
 #define OHCI_REG_INTERRUPTENABLE (0x10) /* HcInterruptEnable */
 #define OHCI_REG_INTERRUPTDISABLE (0x14) /* HcInterruptDisable */
 #define OHCI_REG_HCCA (0x18) /* HcHCCA */
 #define OHCI_REG_PERIODCURRENTED (0x1C) /* HcPeriodCurrentED */
 #define OHCI_REG_CONTROLHEADED (0x20) /* HcControlHeadED */
 #define OHCI_REG_CONTROLCURRENTED (0x24) /* HcControlCurrentED */
 #define OHCI_REG_BULKHEADED (0x28) /* HcBulkHeadED */
 #define OHCI_REG_BULKCURRENTED (0x2C) /* HcBulkCurrentED */
 #define OHCI_REG_DONEHEADED (0x30) /* HcDoneHead */
 #define OHCI_REG_FMINTERVAL (0x34) /* HcFmInterval */
 #define OHCI_REG_FMREMAINING (0x38) /* HcFmRemaining */
 #define OHCI_REG_FMNUMBER (0x3C) /* HcFmNumber */
 #define OHCI_REG_PERIODICSTART (0x40) /* HcPeriodicStart */
 #define OHCI_REG_LSTHRESHOLD (0x44) /* HcLSThreshold */
 #define OHCI_REG_RHDESCRIPTORA (0x48) /* HcRhDescriptorA */
 #define OHCI_REG_RHDESCRIPTORB (0x4C) /* HcRhDescriptorB */
 #define OHCI_REG_RHSTATUS (0x50) /* HcRhStatus */
 #define OHCI_REG_RHPORTSTATUS1 (0x54) /* HcRhPortStatus1 */

 typedef void (usbisr_fnc_t)(void);

 extern void ohciwrapp_init(usbisr_fnc_t *p_usbisr_fnc);
 extern uint32_t ohciwrapp_reg_r(uint32_t reg_ofs);
 extern void ohciwrapp_reg_w(uint32_t reg_ofs, uint32_t set_data);
 extern void ohciwrapp_interrupt(uint32_t int_sense);

 #ifdef __cplusplus
 }
 #endif

 #endif /* OHCI_WRAPP_RZ_A1_H */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_RZ_A1_local.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_RZ_A1_local.h
@@ -0,0 +1,49 @@
 /* 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 OHCI_WRAPP_RZ_A1_LOCAL_H
 #define OHCI_WRAPP_RZ_A1_LOCAL_H

 #ifdef __cplusplus
 extern "C" {
 #endif

 /* ConditionCode */
 #define TD_CC_NOERROR (0)
 #define TD_CC_CRC (1)
 #define TD_CC_BITSTUFFING (2)
 #define TD_CC_DATATOGGLEMISMATCH (3)
 #define TD_CC_STALL (4)
 #define TD_CC_DEVICENOTRESPONDING (5)
 #define TD_CC_PIDCHECKFAILURE (6)
 #define TD_CC_UNEXPECTEDPID (7)
 #define TD_CC_DATAOVERRUN (8)
 #define TD_CC_DATAUNDERRUN (9)
 #define TD_CC_BUFFEROVERRUN (12)
 #define TD_CC_BUFFERUNDERRUN (13)
 #define TD_CC_NOT_ACCESSED_1 (14)
 #define TD_CC_NOT_ACCESSED_2 (15)

 extern void ohciwrapp_loc_Connect(uint32_t type);
 extern void ohciwrapp_loc_TransEnd(uint32_t pipe, uint32_t ConditionCode);

 #ifdef __cplusplus
 }
 #endif

 #endif /* OHCI_WRAPP_RZ_A1_LOCAL_H */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_pipe.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/ohci_wrapp_pipe.c
@@ -0,0 +1,190 @@
 /*******************************************************************************
 * 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.
 *******************************************************************************/

 /*******************************************************************************
 Includes <System Includes> , "Project Includes"
 *******************************************************************************/
 #include "devdrv_usb_host_api.h"


 /*******************************************************************************
 Typedef definitions
 *******************************************************************************/


 /*******************************************************************************
 Macro definitions
 *******************************************************************************/


 /*******************************************************************************
 Imported global variables and functions (from other files)
 *******************************************************************************/


 /*******************************************************************************
 Exported global variables and functions (to be accessed by other files)
 *******************************************************************************/


 /********************************************************************************************************/
 /* Endpoint Configuration Data Format */
 /********************************************************************************************************/
 /* LINE1: Pipe Window Select Register */
 /* CPU Access PIPE : PIPE1 to PIPE9 [ ### SET ### ] */
 /* LINE2: Pipe Configuration Register */
 /* Transfer Type : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* Buffer Ready interrupt : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* Double Buffer Mode : USB_HOST_CNT_ON / USB_HOST_CNT_OFF [ ### SET ### ] */
 /* Continuous Transmit: : USB_HOST_CNT_ON / USB_HOST_CNT_OFF [ ### SET ### ] */
 /* Short NAK : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* Transfer Direction : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* Endpoint Number : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* LINE3: Pipe Buffer Configuration Register */
 /* Buffer Size : (uint16_t)((uint16_t)(((x) / 64) - 1) << 10) */
 /* [ ### SET ### ] */
 /* Buffer Top Number : (uint16_t)(x) [ ### SET ### ] */
 /* LINE4: Pipe Maxpacket Size Register */
 /* Max Packet Size : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* LINE5: Pipe Cycle Configuration Register (0x6C) */
 /* ISO Buffer Flush Mode : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* ISO Interval Value : USB_HOST_NONE [ USB_HOST_NONE ] */
 /* LINE6: use FIFO port */
 /* : USB_HOST_CUSE [ ### SET ### ] */
 /* : USB_HOST_D0USE / USB_HOST_D1USE */
 /* : USB_HOST_D0DMA / USB_HOST_D0DMA */
 /* LINE7: use FIFO port Endian : USB_HOST_FIFO_BIG / USB_HOST_FIFO_LITTLE [ #SET# ] */
 /********************************************************************************************************/

 /* Device Address 1 */
 USB_HOST_CFG_PIPETBL_t usb_host_blk_ep_tbl1[ ] =
 {
 {
 USB_HOST_PIPE3,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((1024) / 64) - 1) << 10) | (uint16_t)(8),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D0USE
 },

 {
 /* Pipe end */
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF
 }
 };

 USB_HOST_CFG_PIPETBL_t usb_host_int_ep_tbl1[ ] =
 {
 {
 USB_HOST_PIPE6,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((64) / 64) - 1) << 10) | (uint16_t)(40),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D1USE
 },

 {
 USB_HOST_PIPE7,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((64) / 64) - 1) << 10) | (uint16_t)(41),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D1USE
 },

 {
 USB_HOST_PIPE8,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((64) / 64) - 1) << 10) | (uint16_t)(42),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D1USE
 },

 {
 USB_HOST_PIPE9,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((64) / 64) - 1) << 10) | (uint16_t)(43),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D1USE
 },

 {
 /* Pipe end */
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF
 }
 };

 USB_HOST_CFG_PIPETBL_t usb_host_iso_ep_tbl1[ ] =
 {
 {
 USB_HOST_PIPE1,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((1024) / 64) - 1) << 10) | (uint16_t)(44),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D1USE
 },

 {
 USB_HOST_PIPE2,
 /* TYPE / BFRE / DBLB / CNTMD / SHTNAK / DIR / EPNUM */
 USB_HOST_NONE | USB_HOST_NONE | USB_HOST_DBLBON | USB_HOST_CNTMDON | USB_HOST_NONE | USB_HOST_NONE | USB_HOST_NONE,
 (uint16_t)((uint16_t)(((1024) / 64) - 1) << 10) | (uint16_t)(60),
 USB_HOST_NONE,
 USB_HOST_NONE,
 USB_HOST_D1USE
 },

 {
 /* Pipe end */
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF,
 0xFFFF
 }
 };


 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_host.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_host.h
@@ -0,0 +1,156 @@
 /*******************************************************************************
 * 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_host.h
 * $Rev: 1116 $
 * $Date:: 2014-07-09 16:29:19 +0900#$
 * Description : RZ/A1H R7S72100 USB Sample Program
 *******************************************************************************/
 #ifndef USB0_HOST_H
 #define USB0_HOST_H

 /*******************************************************************************
 Includes <System Includes> , "Project Includes"
 *******************************************************************************/
 #include "devdrv_usb_host_api.h"
 #include "usb_host.h"

 /*******************************************************************************
 Imported global variables and functions (from other files)
 *******************************************************************************/
 extern const uint16_t g_usb0_host_bit_set[];
 extern uint32_t g_usb0_host_data_count[USB_HOST_MAX_PIPE_NO + 1];
 extern uint8_t *g_usb0_host_data_pointer[USB_HOST_MAX_PIPE_NO + 1];

 extern uint16_t g_usb0_host_PipeIgnore[];
 extern uint16_t g_usb0_host_PipeTbl[];
 extern uint16_t g_usb0_host_pipe_status[];
 extern uint32_t g_usb0_host_PipeDataSize[];

 extern USB_HOST_DMA_t g_usb0_host_DmaInfo[];
 extern uint16_t g_usb0_host_DmaPipe[];
 extern uint16_t g_usb0_host_DmaBval[];
 extern uint16_t g_usb0_host_DmaStatus[];

 extern uint16_t g_usb0_host_driver_state;
 extern uint16_t g_usb0_host_ConfigNum;
 extern uint16_t g_usb0_host_CmdStage;
 extern uint16_t g_usb0_host_bchg_flag;
 extern uint16_t g_usb0_host_detach_flag;
 extern uint16_t g_usb0_host_attach_flag;

 extern uint16_t g_usb0_host_UsbAddress;
 extern uint16_t g_usb0_host_setUsbAddress;
 extern uint16_t g_usb0_host_default_max_packet[USB_HOST_MAX_DEVICE + 1];
 extern uint16_t g_usb0_host_UsbDeviceSpeed;
 extern uint16_t g_usb0_host_SupportUsbDeviceSpeed;

 extern uint16_t g_usb0_host_SavReq;
 extern uint16_t g_usb0_host_SavVal;
 extern uint16_t g_usb0_host_SavIndx;
 extern uint16_t g_usb0_host_SavLen;

 extern uint16_t g_usb0_host_pipecfg[USB_HOST_MAX_PIPE_NO + 1];
 extern uint16_t g_usb0_host_pipebuf[USB_HOST_MAX_PIPE_NO + 1];
 extern uint16_t g_usb0_host_pipemaxp[USB_HOST_MAX_PIPE_NO + 1];
 extern uint16_t g_usb0_host_pipeperi[USB_HOST_MAX_PIPE_NO + 1];

 /*******************************************************************************
 Functions Prototypes
 *******************************************************************************/
 /* ==== common ==== */
 void usb0_host_dma_stop_d0(uint16_t pipe, uint32_t remain);
 void usb0_host_dma_stop_d1(uint16_t pipe, uint32_t remain);
 uint16_t usb0_host_is_hispeed(void);
 uint16_t usb0_host_is_hispeed_enable(void);
 uint16_t usb0_host_start_send_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
 uint16_t usb0_host_write_buffer(uint16_t pipe);
 uint16_t usb0_host_write_buffer_c(uint16_t pipe);
 uint16_t usb0_host_write_buffer_d0(uint16_t pipe);
 uint16_t usb0_host_write_buffer_d1(uint16_t pipe);
 void usb0_host_start_receive_transfer(uint16_t pipe, uint32_t size, uint8_t *data);
 uint16_t usb0_host_read_buffer(uint16_t pipe);
 uint16_t usb0_host_read_buffer_c(uint16_t pipe);
 uint16_t usb0_host_read_buffer_d0(uint16_t pipe);
 uint16_t usb0_host_read_buffer_d1(uint16_t pipe);
 uint16_t usb0_host_change_fifo_port(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
 void usb0_host_set_curpipe(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw);
 void usb0_host_set_curpipe2(uint16_t pipe, uint16_t fifosel, uint16_t isel, uint16_t mbw, uint16_t dfacc);
 uint16_t usb0_host_get_mbw(uint32_t trncount, uint32_t dtptr);
 uint16_t usb0_host_read_dma(uint16_t pipe);
 void usb0_host_stop_transfer(uint16_t pipe);
 void usb0_host_brdy_int(uint16_t status, uint16_t int_enb);
 void usb0_host_nrdy_int(uint16_t status, uint16_t int_enb);
 void usb0_host_bemp_int(uint16_t status, uint16_t int_enb);
 void usb0_host_setting_interrupt(uint8_t level);
 void usb0_host_reset_module(uint16_t clockmode);
 uint16_t usb0_host_get_buf_size(uint16_t pipe);
 uint16_t usb0_host_get_mxps(uint16_t pipe);
 void usb0_host_enable_brdy_int(uint16_t pipe);
 void usb0_host_disable_brdy_int(uint16_t pipe);
 void usb0_host_clear_brdy_sts(uint16_t pipe);
 void usb0_host_enable_bemp_int(uint16_t pipe);
 void usb0_host_disable_bemp_int(uint16_t pipe);
 void usb0_host_clear_bemp_sts(uint16_t pipe);
 void usb0_host_enable_nrdy_int(uint16_t pipe);
 void usb0_host_disable_nrdy_int(uint16_t pipe);
 void usb0_host_clear_nrdy_sts(uint16_t pipe);
 void usb0_host_set_pid_buf(uint16_t pipe);
 void usb0_host_set_pid_nak(uint16_t pipe);
 void usb0_host_set_pid_stall(uint16_t pipe);
 void usb0_host_clear_pid_stall(uint16_t pipe);
 uint16_t usb0_host_get_pid(uint16_t pipe);
 void usb0_host_set_sqclr(uint16_t pipe);
 void usb0_host_set_sqset(uint16_t pipe);
 void usb0_host_set_csclr(uint16_t pipe);
 void usb0_host_aclrm(uint16_t pipe);
 void usb0_host_set_aclrm(uint16_t pipe);
 void usb0_host_clr_aclrm(uint16_t pipe);
 uint16_t usb0_host_get_sqmon(uint16_t pipe);
 uint16_t usb0_host_get_inbuf(uint16_t pipe);

 /* ==== host ==== */
 void usb0_host_init_pipe_status(void);
 int32_t usb0_host_CtrlTransStart(uint16_t devadr, uint16_t Req, uint16_t Val, uint16_t Indx, uint16_t Len, uint8_t *Buf);
 void usb0_host_SetupStage(uint16_t Req, uint16_t Val, uint16_t Indx, uint16_t Len);
 void usb0_host_CtrlReadStart(uint32_t Bsize, uint8_t *Table);
 uint16_t usb0_host_CtrlWriteStart(uint32_t Bsize, uint8_t *Table);
 void usb0_host_StatusStage(void);
 void usb0_host_get_devadd(uint16_t addr, uint16_t *devadd);
 void usb0_host_set_devadd(uint16_t addr, uint16_t *devadd);
 void usb0_host_InitModule(void);
 uint16_t usb0_host_CheckAttach(void);
 void usb0_host_UsbDetach(void);
 void usb0_host_UsbDetach2(void);
 void usb0_host_UsbAttach(void);
 uint16_t usb0_host_UsbBusReset(void);
 int32_t usb0_host_UsbResume(void);
 int32_t usb0_host_UsbSuspend(void);
 void usb0_host_Enable_DetachINT(void);
 void usb0_host_Disable_DetachINT(void);
 void usb0_host_UsbStateManager(void);


 #endif /* USB0_HOST_H */

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_host_api.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_host_api.h
@@ -0,0 +1,112 @@
 /*******************************************************************************
 * 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_host_api.h
 * $Rev: 1116 $
 * $Date:: 2014-07-09 16:29:19 +0900#$
 * Description : RZ/A1H R7S72100 USB Sample Program
 *******************************************************************************/
 #ifndef USB0_HOST_API_H
 #define USB0_HOST_API_H


 /*******************************************************************************
 Typedef definitions
 *******************************************************************************/


 /*******************************************************************************
 Macro definitions
 *******************************************************************************/


 /*******************************************************************************
 Variable Externs
 *******************************************************************************/


 /*******************************************************************************
 Functions Prototypes
 *******************************************************************************/
 void usb0_host_interrupt(uint32_t int_sense);
 void usb0_host_dma_interrupt_d0fifo(uint32_t int_sense);
 void usb0_host_dma_interrupt_d1fifo(uint32_t int_sense);

 uint16_t usb0_api_host_init(uint8_t int_level, uint16_t mode, uint16_t clockmode);
 int32_t usb0_api_host_enumeration(uint16_t devadr);
 int32_t usb0_api_host_detach(void);
 int32_t usb0_api_host_data_in(uint16_t devadr, uint16_t Pipe, uint32_t Size, uint8_t *data_buf);
 int32_t usb0_api_host_data_out(uint16_t devadr, uint16_t Pipe, uint32_t Size, uint8_t *data_buf);
 int32_t usb0_api_host_control_transfer(uint16_t devadr, uint16_t Req, uint16_t Val, uint16_t Indx, uint16_t Len, uint8_t *Buf);
 int32_t usb0_api_host_set_endpoint(uint16_t devadr, USB_HOST_CFG_PIPETBL_t *user_table, uint8_t *configdescriptor);
 int32_t usb0_api_host_clear_endpoint(USB_HOST_CFG_PIPETBL_t *user_table);
 int32_t usb0_api_host_clear_endpoint_pipe(uint16_t pipe_sel, USB_HOST_CFG_PIPETBL_t *user_table);
 uint16_t usb0_api_host_SetEndpointTable(uint16_t devadr, USB_HOST_CFG_PIPETBL_t *user_table, uint8_t* Table);
 int32_t usb0_api_host_data_count(uint16_t pipe, uint32_t *data_count);

 int32_t usb0_api_host_GetDeviceDescriptor(uint16_t devadr, uint16_t size, uint8_t *buf);
 int32_t usb0_api_host_GetConfigDescriptor(uint16_t devadr, uint16_t size, uint8_t *buf);
 int32_t usb0_api_host_SetConfig(uint16_t devadr, uint16_t confignum);
 int32_t usb0_api_host_SetInterface(uint16_t devadr, uint16_t interface_alt, uint16_t interface_index);
 int32_t usb0_api_host_ClearStall(uint16_t devadr, uint16_t ep_dir);
 uint16_t usb0_api_host_GetUsbDeviceState(void);

 void usb0_api_host_elt_4_4(void);
 void usb0_api_host_elt_4_5(void);
 void usb0_api_host_elt_4_6(void);
 void usb0_api_host_elt_4_7(void);
 void usb0_api_host_elt_4_8(void);
 void usb0_api_host_elt_4_9(void);
 void usb0_api_host_elt_get_desc(void);

 void usb0_host_EL_ModeInit(void);
 void usb0_host_EL_SetUACT(void);
 void usb0_host_EL_ClearUACT(void);
 void usb0_host_EL_SetTESTMODE(uint16_t mode);
 void usb0_host_EL_ClearNRDYSTS(uint16_t pipe);
 uint16_t usb0_host_EL_GetINTSTS1(void);
 void usb0_host_EL_UsbBusReset(void);
 void usb0_host_EL_UsbAttach(void);
 void usb0_host_EL_SetupStage(uint16_t Req, uint16_t Val, uint16_t Indx, uint16_t Len);
 void usb0_host_EL_StatusStage(void);
 void usb0_host_EL_CtrlReadStart(uint32_t Bsize, uint8_t *Table);
 int32_t usb0_host_EL_UsbSuspend(void);
 int32_t usb0_host_EL_UsbResume(void);

 #if 0 /* prototype in devdrv_usb_host_api.h */
 uint16_t Userdef_USB_usb0_host_d0fifo_dmaintid(void);
 uint16_t Userdef_USB_usb0_host_d1fifo_dmaintid(void);
 void Userdef_USB_usb0_host_attach(void);
 void Userdef_USB_usb0_host_detach(void);
 void Userdef_USB_usb0_host_delay_1ms(void);
 void Userdef_USB_usb0_host_delay_xms(uint32_t msec);
 void Userdef_USB_usb0_host_delay_10us(uint32_t usec);
 void Userdef_USB_usb0_host_delay_500ns(void);
 void Userdef_USB_usb0_host_start_dma(USB_HOST_DMA_t *dma, uint16_t dfacc);
 uint32_t Userdef_USB_usb0_host_stop_dma0(void);
 uint32_t Userdef_USB_usb0_host_stop_dma1(void);
 #endif

 #endif /* USB0_HOST_API_H */

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_host_dmacdrv.h
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/inc/usb0_host_dmacdrv.h
@@ -0,0 +1,139 @@
 /*******************************************************************************
 * 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_host_dmacdrv.h
 * $Rev: 1116 $
 * $Date:: 2014-07-09 16:29:19 +0900#$
 * Description : RZ/A1H R7S72100 USB Sample Program
 *******************************************************************************/
 #ifndef USB0_HOST_DMACDRV_H
 #define USB0_HOST_DMACDRV_H


 /*******************************************************************************
 Includes <System Includes> , "Project Includes"
 *******************************************************************************/


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


 /*******************************************************************************
 Variable Externs
 *******************************************************************************/


 /*******************************************************************************
 Functions Prototypes
 *******************************************************************************/
 void usb0_host_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_host_DMAC1_Open(uint32_t req);
 void usb0_host_DMAC1_Close(uint32_t * remain);
 void usb0_host_DMAC1_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count);

 void usb0_host_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_host_DMAC2_Open(uint32_t req);
 void usb0_host_DMAC2_Close(uint32_t * remain);
 void usb0_host_DMAC2_Load_Set(uint32_t src_addr, uint32_t dst_addr, uint32_t count);

 #endif /* USB0_HOST_DMACDRV_H */

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_dataio.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_dataio.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_dma.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_dma.c
@@ -0,0 +1,355 @@
 /*******************************************************************************
 * 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_host_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_host.h"
 /* #include "usb0_host_dmacdrv.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_host_dmaint(uint16_t fifo);
 static void usb0_host_dmaint_buf2fifo(uint16_t pipe);
 static void usb0_host_dmaint_fifo2buf(uint16_t pipe);


 /*******************************************************************************
 * Function Name: usb0_host_dma_stop_d0
 * Description : D0FIFO DMA stop
 * Arguments : uint16_t pipe : pipe number
 * : uint32_t remain : transfer byte
 * Return Value : none
 *******************************************************************************/
 void usb0_host_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_host_DmaInfo[USB_HOST_D0FIFO].size == 2)
 {
 sds_b = 4;
 }
 else if (g_usb0_host_DmaInfo[USB_HOST_D0FIFO].size == 1)
 {
 sds_b = 2;
 }
 else
 {
 sds_b = 1;
 }
 }

 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
 {
 if (g_usb0_host_pipe_status[pipe] != USB_HOST_PIPE_DONE)
 {
 buffer = USB200.D0FIFOCTR;
 dtln = (buffer & USB_HOST_BITDTLN);

 if ((dtln % sds_b) != 0)
 {
 remain += (sds_b - (dtln % sds_b));
 }
 g_usb0_host_PipeDataSize[pipe] = (g_usb0_host_data_count[pipe] - remain);
 g_usb0_host_data_count[pipe] = remain;
 }
 }

 RZA_IO_RegWrite_16(&USB200.D0FIFOSEL,
 0,
 USB_DnFIFOSEL_DREQE_SHIFT,
 USB_DnFIFOSEL_DREQE);
 }

 /*******************************************************************************
 * Function Name: usb0_host_dma_stop_d1
 * Description : D1FIFO DMA stop
 * Arguments : uint16_t pipe : pipe number
 * : uint32_t remain : transfer byte
 * Return Value : none
 *******************************************************************************/
 void usb0_host_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_host_DmaInfo[USB_HOST_D1FIFO].size == 2)
 {
 sds_b = 4;
 }
 else if (g_usb0_host_DmaInfo[USB_HOST_D1FIFO].size == 1)
 {
 sds_b = 2;
 }
 else
 {
 sds_b = 1;
 }
 }

 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 1)
 {
 if (g_usb0_host_pipe_status[pipe] != USB_HOST_PIPE_DONE)
 {
 buffer = USB200.D1FIFOCTR;
 dtln = (buffer & USB_HOST_BITDTLN);

 if ((dtln % sds_b) != 0)
 {
 remain += (sds_b - (dtln % sds_b));
 }
 g_usb0_host_PipeDataSize[pipe] = (g_usb0_host_data_count[pipe] - remain);
 g_usb0_host_data_count[pipe] = remain;
 }
 }

 RZA_IO_RegWrite_16(&USB200.D1FIFOSEL,
 0,
 USB_DnFIFOSEL_DREQE_SHIFT,
 USB_DnFIFOSEL_DREQE);
 }

 /*******************************************************************************
 * Function Name: usb0_host_dma_interrupt_d0fifo
 * Description : This function is DMA interrupt handler entry.
 * : Execute usb1_host_dmaint() after disabling DMA interrupt in this function.
 * : Disable DMA interrupt to DMAC executed when USB_HOST_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_host_dma_interrupt_d0fifo (uint32_t int_sense)
 {
 usb0_host_dmaint(USB_HOST_D0FIFO);
 g_usb0_host_DmaStatus[USB_HOST_D0FIFO] = USB_HOST_DMA_READY;
 }

 /*******************************************************************************
 * Function Name: usb0_host_dma_interrupt_d1fifo
 * Description : This function is DMA interrupt handler entry.
 * : Execute usb0_host_dmaint() after disabling DMA interrupt in this function.
 * : Disable DMA interrupt to DMAC executed when USB_HOST_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_host_dma_interrupt_d1fifo (uint32_t int_sense)
 {
 usb0_host_dmaint(USB_HOST_D1FIFO);
 g_usb0_host_DmaStatus[USB_HOST_D1FIFO] = USB_HOST_DMA_READY;
 }

 /*******************************************************************************
 * Function Name: usb0_host_dmaint
 * Description : This function is DMA transfer end interrupt
 * Arguments : uint16_t fifo ; fifo number
 * : ; USB_HOST_D0FIFO
 * : ; USB_HOST_D1FIFO
 * Return Value : none
 *******************************************************************************/
 static void usb0_host_dmaint (uint16_t fifo)
 {
 uint16_t pipe;

 pipe = g_usb0_host_DmaPipe[fifo];

 if (g_usb0_host_DmaInfo[fifo].dir == USB_HOST_BUF2FIFO)
 {
 usb0_host_dmaint_buf2fifo(pipe);
 }
 else
 {
 usb0_host_dmaint_fifo2buf(pipe);
 }
 }

 /*******************************************************************************
 * Function Name: usb0_host_dmaint_fifo2buf
 * Description : Executes read completion from FIFO by DMAC.
 * Arguments : uint16_t pipe : pipe number
 * Return Value : none
 *******************************************************************************/
 static void usb0_host_dmaint_fifo2buf (uint16_t pipe)
 {
 uint32_t remain;
 uint16_t useport;

 if (g_usb0_host_pipe_status[pipe] != USB_HOST_PIPE_DONE)
 {
 useport = (uint16_t)(g_usb0_host_PipeTbl[pipe] & USB_HOST_FIFO_USE);

 if (useport == USB_HOST_D0FIFO_DMA)
 {
 remain = Userdef_USB_usb0_host_stop_dma0();
 usb0_host_dma_stop_d0(pipe, remain);

 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
 {
 if (g_usb0_host_DmaStatus[USB_HOST_D0FIFO] == USB_HOST_DMA_BUSYEND)
 {
 USB200.D0FIFOCTR = USB_HOST_BITBCLR;
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_DONE;
 }
 else
 {
 usb0_host_enable_brdy_int(pipe);
 }
 }
 }
 else
 {
 remain = Userdef_USB_usb0_host_stop_dma1();
 usb0_host_dma_stop_d1(pipe, remain);

 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
 {
 if (g_usb0_host_DmaStatus[USB_HOST_D1FIFO] == USB_HOST_DMA_BUSYEND)
 {
 USB200.D1FIFOCTR = USB_HOST_BITBCLR;
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_DONE;
 }
 else
 {
 usb0_host_enable_brdy_int(pipe);
 }
 }
 }
 }
 }

 /*******************************************************************************
 * Function Name: usb0_host_dmaint_buf2fifo
 * Description : Executes write completion in FIFO by DMAC.
 * Arguments : uint16_t pipe : pipe number
 * Return Value : none
 *******************************************************************************/
 static void usb0_host_dmaint_buf2fifo (uint16_t pipe)
 {
 uint16_t useport;
 uint32_t remain;

 useport = (uint16_t)(g_usb0_host_PipeTbl[pipe] & USB_HOST_FIFO_USE);

 if (useport == USB_HOST_D0FIFO_DMA)
 {
 remain = Userdef_USB_usb0_host_stop_dma0();
 usb0_host_dma_stop_d0(pipe, remain);

 if (g_usb0_host_DmaBval[USB_HOST_D0FIFO] != 0)
 {
 RZA_IO_RegWrite_16(&USB200.D0FIFOCTR,
 1,
 USB_DnFIFOCTR_BVAL_SHIFT,
 USB_DnFIFOCTR_BVAL);
 }
 }
 else
 {
 remain = Userdef_USB_usb0_host_stop_dma1();
 usb0_host_dma_stop_d1(pipe, remain);

 if (g_usb0_host_DmaBval[USB_HOST_D1FIFO] != 0)
 {
 RZA_IO_RegWrite_16(&USB200.D1FIFOCTR,
 1,
 USB_DnFIFOCTR_BVAL_SHIFT,
 USB_DnFIFOCTR_BVAL);
 }
 }

 usb0_host_enable_bemp_int(pipe);
 }

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_intrn.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_intrn.c
@@ -0,0 +1,285 @@
 /*******************************************************************************
 * 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_host_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_host.h"
 #if(1) /* ohci_wrapp */
 #include "ohci_wrapp_RZ_A1_local.h"
 #endif


 /*******************************************************************************
 Typedef definitions
 *******************************************************************************/


 /*******************************************************************************
 Macro definitions
 *******************************************************************************/


 /*******************************************************************************
 Imported global variables and functions (from other files)
 *******************************************************************************/


 /*******************************************************************************
 Exported global variables and functions (to be accessed by other files)
 *******************************************************************************/


 /*******************************************************************************
 Private global variables and functions
 *******************************************************************************/


 /*******************************************************************************
 * Function Name: usb0_host_brdy_int
 * Description : Executes BRDY interrupt(USB_HOST_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_enb ; BRDYENB Register Value
 * Return Value : none
 *******************************************************************************/
 void usb0_host_brdy_int (uint16_t status, uint16_t int_enb)
 {
 uint32_t int_sense = 0;
 uint16_t pipe;
 uint16_t pipebit;

 for (pipe = USB_HOST_PIPE1; pipe <= USB_HOST_MAX_PIPE_NO; pipe++)
 {
 pipebit = g_usb0_host_bit_set[pipe];

 if ((status & pipebit) && (int_enb & pipebit))
 {
 USB200.BRDYSTS = (uint16_t)~pipebit;
 USB200.BEMPSTS = (uint16_t)~pipebit;

 if ((g_usb0_host_PipeTbl[pipe] & USB_HOST_FIFO_USE) == USB_HOST_D0FIFO_DMA)
 {
 if (g_usb0_host_DmaStatus[USB_HOST_D0FIFO] != USB_HOST_DMA_READY)
 {
 usb0_host_dma_interrupt_d0fifo(int_sense);
 }

 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
 {
 usb0_host_read_dma(pipe);
 usb0_host_disable_brdy_int(pipe);
 }
 else
 {
 USB200.D0FIFOCTR = USB_HOST_BITBCLR;
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_DONE;
 }
 }
 else if ((g_usb0_host_PipeTbl[pipe] & USB_HOST_FIFO_USE) == USB_HOST_D1FIFO_DMA)
 {
 if (g_usb0_host_DmaStatus[USB_HOST_D1FIFO] != USB_HOST_DMA_READY)
 {
 usb0_host_dma_interrupt_d1fifo(int_sense);
 }

 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_BFRE_SHIFT, USB_PIPECFG_BFRE) == 0)
 {
 usb0_host_read_dma(pipe);
 usb0_host_disable_brdy_int(pipe);
 }
 else
 {
 USB200.D1FIFOCTR = USB_HOST_BITBCLR;
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_DONE;
 }
 }
 else
 {
 if (RZA_IO_RegRead_16(&g_usb0_host_pipecfg[pipe], USB_PIPECFG_DIR_SHIFT, USB_PIPECFG_DIR) == 0)
 {
 usb0_host_read_buffer(pipe);
 }
 else
 {
 usb0_host_write_buffer(pipe);
 }
 }
 #if(1) /* ohci_wrapp */
 switch (g_usb0_host_pipe_status[pipe])
 {
 case USB_HOST_PIPE_DONE:
 ohciwrapp_loc_TransEnd(pipe, TD_CC_NOERROR);
 break;
 case USB_HOST_PIPE_NORES:
 case USB_HOST_PIPE_STALL:
 case USB_HOST_PIPE_ERROR:
 ohciwrapp_loc_TransEnd(pipe, TD_CC_STALL);
 break;
 default:
 /* Do Nothing */
 break;
 }
 #endif
 }
 }
 }

 /*******************************************************************************
 * Function Name: usb0_host_nrdy_int
 * Description : Executes NRDY interrupt(USB_HOST_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 USB_HOST_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_host_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_HOST_PIPE1; pipe <= USB_HOST_MAX_PIPE_NO; pipe++)
 {
 if ((bitcheck&g_usb0_host_bit_set[pipe]) == g_usb0_host_bit_set[pipe])
 {
 if (RZA_IO_RegRead_16(&USB200.SYSCFG0,
 USB_SYSCFG_DCFM_SHIFT,
 USB_SYSCFG_DCFM) == 1)
 {
 if (g_usb0_host_pipe_status[pipe] == USB_HOST_PIPE_WAIT)
 {
 pid = usb0_host_get_pid(pipe);

 if ((pid == USB_HOST_PID_STALL) || (pid == USB_HOST_PID_STALL2))
 {
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_STALL;
 #if(1) /* ohci_wrapp */
 ohciwrapp_loc_TransEnd(pipe, TD_CC_STALL);
 #endif
 }
 else
 {
 #if(1) /* ohci_wrapp */
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_NORES;
 ohciwrapp_loc_TransEnd(pipe, TD_CC_DEVICENOTRESPONDING);
 #else
 g_usb0_host_PipeIgnore[pipe]++;

 if (g_usb0_host_PipeIgnore[pipe] == 3)
 {
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_NORES;
 }
 else
 {
 usb0_host_set_pid_buf(pipe);
 }
 #endif
 }
 }
 }
 else
 {
 /* USB Function */
 }
 }
 }
 }

 /*******************************************************************************
 * Function Name: usb0_host_bemp_int
 * Description : Executes BEMP interrupt(USB_HOST_PIPE1-9).
 * Arguments : uint16_t status ; BEMPSTS Register Value
 * : uint16_t int_enb ; BEMPENB Register Value
 * Return Value : none
 *******************************************************************************/
 void usb0_host_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_HOST_PIPE1; pipe <= USB_HOST_MAX_PIPE_NO; pipe++)
 {
 if ((bitcheck&g_usb0_host_bit_set[pipe]) == g_usb0_host_bit_set[pipe])
 {
 pid = usb0_host_get_pid(pipe);

 if ((pid == USB_HOST_PID_STALL) || (pid == USB_HOST_PID_STALL2))
 {
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_STALL;
 #if(1) /* ohci_wrapp */
 ohciwrapp_loc_TransEnd(pipe, TD_CC_STALL);
 #endif
 }
 else
 {
 inbuf = usb0_host_get_inbuf(pipe);

 if (inbuf == 0)
 {
 usb0_host_disable_bemp_int(pipe);
 usb0_host_set_pid_nak(pipe);
 g_usb0_host_pipe_status[pipe] = USB_HOST_PIPE_DONE;
 #if(1) /* ohci_wrapp */
 ohciwrapp_loc_TransEnd(pipe, TD_CC_NOERROR);
 #endif
 }
 }
 }
 }
 }

 /* End of File */
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_lib.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/common/usb0_host_lib.c
--- a/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/host/usb0_host_controlrw.c
+++ b/tmk_core/tool/mbed/mbed-sdk/libraries/USBHost/USBHost/TARGET_RENESAS/TARGET_RZ_A1H/usb0/src/host/usb0_host_controlrw.c