<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<title>Configure USB Peripheral</title>
<title>CMSIS-DAP: Configure USB Peripheral</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="cmsis.css" rel="stylesheet" type="text/css" />
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<script type="text/javascript" src="printComponentTabs.js"></script>
<link href="navtree.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="resize.js"></script>
<script type="text/javascript" src="navtree.js"></script>
<script type="text/javascript">
  $(document).ready(initResizable);
  $(window).load(resizeHeight);
</script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/search.js"></script>
<script type="text/javascript">
  $(document).ready(function() { searchBox.OnSelectItem(0); });
</script>
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 46px;">
  <td id="projectlogo"><img alt="Logo" src="CMSIS_Logo_Final.png"/></td>
  <td style="padding-left: 0.5em;">
   <div id="projectname">CMSIS-DAP
   &#160;<span id="projectnumber">Version 2.0.0</span>
   </div>
   <div id="projectbrief">Interface Firmware for CoreSight Debug Access Port</div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<div id="CMSISnav" class="tabs1">
    <ul class="tablist">
      <script type="text/javascript">
		<!--
		writeComponentTabs.call(this);
		//-->
      </script>
	  </ul>
</div>
<!-- Generated by Doxygen 1.8.6 -->
<script type="text/javascript">
var searchBox = new SearchBox("searchBox", "search",false,'Search');
</script>
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="pages.html"><span>Usage&#160;and&#160;Description</span></a></li>
      <li><a href="modules.html"><span>Reference</span></a></li>
      <li>
        <div id="MSearchBox" class="MSearchBoxInactive">
        <span class="left">
          <img id="MSearchSelect" src="search/mag_sel.png"
               onmouseover="return searchBox.OnSearchSelectShow()"
               onmouseout="return searchBox.OnSearchSelectHide()"
               alt=""/>
          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)" 
               onblur="searchBox.OnSearchFieldFocus(false)" 
               onkeyup="searchBox.OnSearchFieldChange(event)"/>
          </span><span class="right">
            <a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
          </span>
        </div>
      </li>
    </ul>
  </div>
</div><!-- top -->
<div id="side-nav" class="ui-resizable side-nav-resizable">
  <div id="nav-tree">
    <div id="nav-tree-contents">
      <div id="nav-sync" class="sync"></div>
    </div>
  </div>
  <div id="splitbar" style="-moz-user-select:none;" 
       class="ui-resizable-handle">
  </div>
</div>
<script type="text/javascript">
$(document).ready(function(){initNavTree('group__DAP__ConfigUSB__gr.html','');});
</script>
<div id="doc-content">
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark">&#160;</span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark">&#160;</span>Functions</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark">&#160;</span>Groups</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark">&#160;</span>Pages</a></div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div class="header">
  <div class="headertitle">
<div class="title">Configure USB Peripheral<div class="ingroups"><a class="el" href="group__DAP__Config__gr.html">Firmware Configuration</a></div></div>  </div>
</div><!--header-->
<div class="contents">

<p>CMSIS-DAP Firmware communicates via an USB interface to host computer.  
<a href="#details">More...</a></p>
<p>CMSIS-DAP Firmware communicates via an USB interface to host computer. </p>
<p>The USB communication is implemented via MDK middleware components that access the USB peripheral of the microcontroller.</p>
<p>The CMSIS-DAP Firmware is able to communicate with the host computer using one of the following USB classes:</p>
<ul>
<li><a class="el" href="group__DAP__ConfigUSB__gr.html">Communication via USB HID</a> (Human Interface Device) does not require any USB driver installation.</li>
<li><a class="el" href="group__DAP__ConfigUSB__gr.html">Communication via WinUSB</a> provides higher speed communication but may require an *.inf file for USB installation.</li>
</ul>
<p>For the USB interface it is important to provide correct configuration information for the USB Peripheral as described in this section.</p>
<p>The following steps describe how to change and configure the USB peripheral in the CMSIS-DAP Firmware project:</p>
<ol type="1">
<li>In the <b>Project Window</b>, the group <b>USB</b> contains USB interface with the relevant configuration files.</li>
<li>Open the file <b>usb_config_0.c</b> in the editor and select <b>Configuration Wizard</b> as edit mode; then change the following settings:<ul>
<li><b>USB Device 0 - High-speed</b>: enable this option only for a high-speed USB peripheral; disable for full-speed USB.</li>
<li>Update <b>Device Settings - Vendor ID</b> which is provided by the <a href="http://www.usb.org/developers/vendor/" target="_blank">USB Implementers Forum</a>.</li>
<li>Update <b>Device Settings - Product ID</b> to provide a unique identification for the Debug Unit.</li>
<li>Update <b>Device Settings - Device Release Number</b> to indicate the revision of the adaptation.</li>
<li>Update <b>String Settings - Manufacturer String</b> to reflect the vendor of the Debug Unit. This setting should match the <b>Vendor ID</b>.</li>
<li>Update <b>String Settings - Product String</b> to indicate the Debug Unit. Note that "CMSIS-DAP" must be part of that string to allow identification by debuggers (or part of interface string for USB composite device).</li>
<li>Optionally each Debug Unit may provide a unique <b>Serial Number String</b>. If the <b>String Settings - Serial Number String</b> is not provided, only one Debug Unit can be connected at the same time to a host computer since it is impossible to identify multiple Debug Units.</li>
</ul>
</li>
</ol>
<dl class="section note"><dt>Note</dt><dd><ul>
<li>The USB Device setting high-speed / full-speed USB must be reflected in the <b>DAP_config.h</b> file as described under <a class="el" href="group__DAP__Config__gr.html">Firmware Configuration</a>.</li>
<li>The <b>String Settings - Product String</b> must contain "CMSIS-DAP" somewhere in the string. This is used by the debuggers to identify a CMSIS-DAP compliant Debug Unit that is connected to a host computer.</li>
</ul>
</dd></dl>
<p><br/>
 </p>
<div class="image">
<img src="MDK_USB.png" alt="MDK_USB.png"/>
<div class="caption">
Adapt the USB Peripheral to the microcontroller</div></div>


<h3><a class="anchor" id="USBHID"></a>Communication via USB HID</h3><div class="textblock">CMSIS-DAP with V1 configuration uses USB HID and is therefore compatible with previous versions of CMSIS-DAP.There is no modification at the debugger required as all the additions are fully upward compatible. To configure CMSIS-DAP for V1 interface, add to the compiler options the #define DAP_FW_V1 as shown below:<br/>
 </p>
<div class="image">
<img src="MDK_DAP_FW_V1.png" alt="MDK_DAP_FW_V1.png"/>
<div class="caption">
Compiler CMSIS-DAP Firmware for USB HID interface</div></div>
<p> The CMSIS-DAP Firmware can be also part of a USB composite device. If this case, the <b>HID Interface String</b> must contain the sub-string <b>CMSIS-DAP</b>. The <b>HID Interface String</b> is configured in the file USBD_Config_HID_0.h under the category <b>Human Interface Device Class Settings</b>.<br/>
 </p>
<div class="image">
<img src="MDK_USB_HID.png" alt="MDK_USB_HID.png"/>
<div class="caption">
Adapt CMSIS-DAP to the USB HID class</div></div>
</div>

<h3><a class="anchor" id="WinUSB"></a>Communication via WinUSB</h3><div class="textblock">CMSIS-DAP with default V2 configuration uses WinUSB and is therefore faster.Optionally support for streaming SWO trace is provided via an additional USB endpoint.The WinUSB configuration requires custom class support with the interface setting – Class Code: 0xFF (Vendor specific), Subclass: 0x00, Protocol code: 0x00. Depending on the configuration it uses the following USB endpoints which should be configured in the interface descriptor in this order:</p>
<ul>
<li>Endpoint 1: Bulk Out – used for commands received from host PC.</li>
<li>Endpoint 2: Bulk In – used for responses send to host PC.</li>
<li>Endpoint 3: Bulk In (optional) – used for streaming SWO trace (if enabled with <a class="el" href="group__DAP__Config__Debug__gr.html#gafd6f450a10f4e03757388e00ea56906f">SWO_STREAM</a>).</li>
</ul>
To identify a CMSIS-DAP V2 configuration by debuggers the following WinUSB GUID must be used: </p>
<div class="fragment"><div class="line">{CDB3B5AD-293B-4663-AA36-1AAE46463776}</div>
</div><!-- fragment --><p> The picture below shows the configuration of the USB custom class.<div class="image">
<img src="MDK_USB_Custom.png" alt="MDK_USB_Custom.png"/>
<div class="caption">
Adapt CMSIS-DAP to the WinUSB class</div></div>
<p> <b>USB Driver and *.inf file</b> <br/>
<br/>
 Windows 8 and Windows 10 does not require a WinUSB driver provided that the USB firmware stack supports Microsoft descriptors. CMSIS-DAP v2 device should be configured as WCID (Windows Compatible ID) device which provides extra information to a Windows system to facilitate automated driver installation. <br/>
<br/>
 For Windows 7, the CMSIS-DAP v2 device will install automatically if PC is connected to the Internet and Device Installation Settings of PC are set to automatically download and install drivers for devices. Automatically installed device will be seen in Device Manager under Universal Serial Bus devices as WinUsb Device <br/>
<br/>
 If no Internet connection is available or you want device to show with different name under Device Manager you should provide an .inf file and sign it to generate .cat files. More information is available from Microsoft under the topic <a href="https://technet.microsoft.com/en-us/library/dd919238(v=ws.10).aspx" target="_blank">Steps for Signing a Device Driver Package</a>. <br/>
<br/>
The following CMSIS_DAP_v2.inf file should be provided for an Windows 7 host PC.<pre class="fragment">[Version]
Signature = "$Windows NT$"
Class     = USBDevice
ClassGUID = {88BAE032-5A81-49f0-BC3D-A4FF138216D6}
Provider  = %ManufacturerName%
DriverVer = 04/13/2016, 1.0.0.0
CatalogFile.nt      = CMSIS_DAP_v2_x86.cat
CatalogFile.ntx86   = CMSIS_DAP_v2_x86.cat
CatalogFile.ntamd64 = CMSIS_DAP_v2_amd64.cat

; ========== Manufacturer/Models sections ===========

[Manufacturer]
%ManufacturerName% = Devices, NTx86, NTamd64

[Devices.NTx86]
%DeviceName% = USB_Install, USB\VID_c251&amp;PID_f000

[Devices.NTamd64]
%DeviceName% = USB_Install, USB\VID_c251&amp;PID_f000

; ========== Class definition ===========

[ClassInstall32]
AddReg = ClassInstall_AddReg

[ClassInstall_AddReg]
HKR,,,,%ClassName%
HKR,,NoInstallClass,,1
HKR,,IconPath,0x10000,"%%SystemRoot%%\System32\setupapi.dll,-20"
HKR,,LowerLogoVersion,,5.2

; =================== Installation ===================

[USB_Install]
Include = winusb.inf
Needs   = WINUSB.NT

[USB_Install.Services]
Include = winusb.inf
Needs   = WINUSB.NT.Services

[USB_Install.HW]
AddReg  = Dev_AddReg

[Dev_AddReg]
HKR,,DeviceInterfaceGUIDs,0x10000,"{CDB3B5AD-293B-4663-AA36-1AAE46463776}"

; =================== Strings ===================

[Strings]
ClassName        = "Universal Serial Bus devices"
ManufacturerName = "KEIL - Tools By ARM"
DeviceName       = "CMSIS-DAP v2" 
</pre> </div></div><!-- contents -->
</div><!-- doc-content -->
<!-- start footer part -->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
  <ul>
    <li class="footer">Generated on Wed Jul 10 2019 15:20:28 for CMSIS-DAP Version 2.0.0 by Arm Ltd. All rights reserved.
	<!--
    <a href="http://www.doxygen.org/index.html">
    <img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.8.6 
	-->
	</li>
  </ul>
</div>
</body>
</html>
