Junichi Katsu / Mbed 2 deprecated BLEControl

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   FatFileSystem TB6612FNG2 mbed

usb/UsbDevice.cpp@0:de03cbbcd0ff, 2015-11-30 (annotated)

Committer:
mbed_Cookbook_SE
Date:
Mon Nov 30 09:32:15 2015 +0000
Revision:
0:de03cbbcd0ff
??

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_Cookbook_SE 0:de03cbbcd0ff 1
mbed_Cookbook_SE 0:de03cbbcd0ff 2 /*
mbed_Cookbook_SE 0:de03cbbcd0ff 3 Copyright (c) 2010 Donatien Garnier (donatiengar [at] gmail [dot] com)
mbed_Cookbook_SE 0:de03cbbcd0ff 4
mbed_Cookbook_SE 0:de03cbbcd0ff 5 Permission is hereby granted, free of charge, to any person obtaining a copy
mbed_Cookbook_SE 0:de03cbbcd0ff 6 of this software and associated documentation files (the "Software"), to deal
mbed_Cookbook_SE 0:de03cbbcd0ff 7 in the Software without restriction, including without limitation the rights
mbed_Cookbook_SE 0:de03cbbcd0ff 8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
mbed_Cookbook_SE 0:de03cbbcd0ff 9 copies of the Software, and to permit persons to whom the Software is
mbed_Cookbook_SE 0:de03cbbcd0ff 10 furnished to do so, subject to the following conditions:
mbed_Cookbook_SE 0:de03cbbcd0ff 11
mbed_Cookbook_SE 0:de03cbbcd0ff 12 The above copyright notice and this permission notice shall be included in
mbed_Cookbook_SE 0:de03cbbcd0ff 13 all copies or substantial portions of the Software.
mbed_Cookbook_SE 0:de03cbbcd0ff 14
mbed_Cookbook_SE 0:de03cbbcd0ff 15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
mbed_Cookbook_SE 0:de03cbbcd0ff 16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
mbed_Cookbook_SE 0:de03cbbcd0ff 17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
mbed_Cookbook_SE 0:de03cbbcd0ff 18 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
mbed_Cookbook_SE 0:de03cbbcd0ff 19 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
mbed_Cookbook_SE 0:de03cbbcd0ff 20 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
mbed_Cookbook_SE 0:de03cbbcd0ff 21 THE SOFTWARE.
mbed_Cookbook_SE 0:de03cbbcd0ff 22 */
mbed_Cookbook_SE 0:de03cbbcd0ff 23
mbed_Cookbook_SE 0:de03cbbcd0ff 24 #include "UsbDevice.h"
mbed_Cookbook_SE 0:de03cbbcd0ff 25 //#define __DEBUG
mbed_Cookbook_SE 0:de03cbbcd0ff 26 #include "mydbg.h"
mbed_Cookbook_SE 0:de03cbbcd0ff 27
mbed_Cookbook_SE 0:de03cbbcd0ff 28 UsbDevice::UsbDevice( UsbHostMgr* pMgr, int hub, int port, int addr ) : m_pControlEp(NULL), /*m_controlEp( this, 0x00, false, USB_CONTROL, 8 ),*/
mbed_Cookbook_SE 0:de03cbbcd0ff 29 m_pMgr(pMgr), m_connected(false), m_enumerated(false), m_hub(hub), m_port(port), m_addr(addr), m_refs(0),
mbed_Cookbook_SE 0:de03cbbcd0ff 30 m_vid(0), m_pid(0)
mbed_Cookbook_SE 0:de03cbbcd0ff 31 {
mbed_Cookbook_SE 0:de03cbbcd0ff 32 m_DeviceClass = 0x00;
mbed_Cookbook_SE 0:de03cbbcd0ff 33 m_InterfaceClass = 0x00;
mbed_Cookbook_SE 0:de03cbbcd0ff 34 }
mbed_Cookbook_SE 0:de03cbbcd0ff 35
mbed_Cookbook_SE 0:de03cbbcd0ff 36 UsbDevice::~UsbDevice()
mbed_Cookbook_SE 0:de03cbbcd0ff 37 {
mbed_Cookbook_SE 0:de03cbbcd0ff 38 DBG_ASSERT(0);
mbed_Cookbook_SE 0:de03cbbcd0ff 39
mbed_Cookbook_SE 0:de03cbbcd0ff 40 if(m_pControlEp)
mbed_Cookbook_SE 0:de03cbbcd0ff 41 delete m_pControlEp;
mbed_Cookbook_SE 0:de03cbbcd0ff 42 }
mbed_Cookbook_SE 0:de03cbbcd0ff 43
mbed_Cookbook_SE 0:de03cbbcd0ff 44 UsbErr UsbDevice::enumerate()
mbed_Cookbook_SE 0:de03cbbcd0ff 45 {
mbed_Cookbook_SE 0:de03cbbcd0ff 46 VERBOSE("Hub: %d Port: %d\n", m_hub, m_port);
mbed_Cookbook_SE 0:de03cbbcd0ff 47 UsbErr rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 48 DBG("%p m_hub=%d m_port=%d\n", this, m_hub, m_port);
mbed_Cookbook_SE 0:de03cbbcd0ff 49 DBG_ASSERT(m_pMgr);
mbed_Cookbook_SE 0:de03cbbcd0ff 50 m_pMgr->resetPort(m_hub, m_port);
mbed_Cookbook_SE 0:de03cbbcd0ff 51
mbed_Cookbook_SE 0:de03cbbcd0ff 52 wait_ms(400);
mbed_Cookbook_SE 0:de03cbbcd0ff 53
mbed_Cookbook_SE 0:de03cbbcd0ff 54 uint8_t temp[8];
mbed_Cookbook_SE 0:de03cbbcd0ff 55 DBG_ASSERT(m_pControlEp == NULL);
mbed_Cookbook_SE 0:de03cbbcd0ff 56 m_pControlEp = new UsbEndpoint( this, 0x00, false, USB_CONTROL, sizeof(temp), 0 );
mbed_Cookbook_SE 0:de03cbbcd0ff 57 DBG_ASSERT(m_pControlEp);
mbed_Cookbook_SE 0:de03cbbcd0ff 58 //EDCtrl->Control = 8 << 16;/* Put max pkt size = 8 */
mbed_Cookbook_SE 0:de03cbbcd0ff 59 /* Read first 8 bytes of device desc */
mbed_Cookbook_SE 0:de03cbbcd0ff 60 DBG_ASSERT(sizeof(temp) >= 8);
mbed_Cookbook_SE 0:de03cbbcd0ff 61 //rc = controlReceive(
mbed_Cookbook_SE 0:de03cbbcd0ff 62 // USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE, GET_DESCRIPTOR,
mbed_Cookbook_SE 0:de03cbbcd0ff 63 // (USB_DESCRIPTOR_TYPE_DEVICE << 8) |(0), 0, temp, sizeof(temp));
mbed_Cookbook_SE 0:de03cbbcd0ff 64 //DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 65 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_DEVICE, 0, temp, sizeof(temp));
mbed_Cookbook_SE 0:de03cbbcd0ff 66 if (rc != USBERR_OK) {
mbed_Cookbook_SE 0:de03cbbcd0ff 67 DBG("rc=%d\n", rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 68 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 69 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 70 }
mbed_Cookbook_SE 0:de03cbbcd0ff 71 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 72 DBG_BYTES("DeviceDescriptor first 8 bytes", temp, sizeof(temp));
mbed_Cookbook_SE 0:de03cbbcd0ff 73 DBG_ASSERT(temp[0] == 18); // bLength
mbed_Cookbook_SE 0:de03cbbcd0ff 74 DBG_ASSERT(temp[1] == 0x01); // bDescriptType
mbed_Cookbook_SE 0:de03cbbcd0ff 75 if (rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 76 {
mbed_Cookbook_SE 0:de03cbbcd0ff 77 DBG("RC=%d",rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 78 return (rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 79 }
mbed_Cookbook_SE 0:de03cbbcd0ff 80 uint8_t bMaxPacketSize = temp[7];
mbed_Cookbook_SE 0:de03cbbcd0ff 81 DBG_ASSERT(bMaxPacketSize >= 8);
mbed_Cookbook_SE 0:de03cbbcd0ff 82 DBG("Got descriptor, max ep size is %d\n", bMaxPacketSize);
mbed_Cookbook_SE 0:de03cbbcd0ff 83
mbed_Cookbook_SE 0:de03cbbcd0ff 84 m_pControlEp->updateSize(bMaxPacketSize); /* Get max pkt size of endpoint 0 */
mbed_Cookbook_SE 0:de03cbbcd0ff 85 rc = controlSend(USB_HOST_TO_DEVICE | USB_RECIPIENT_DEVICE, SET_ADDRESS, m_addr, 0, NULL, 0); /* Set the device address to m_addr */
mbed_Cookbook_SE 0:de03cbbcd0ff 86 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 87 if (rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 88 {
mbed_Cookbook_SE 0:de03cbbcd0ff 89 // PRINT_Err(rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 90 return (rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 91 }
mbed_Cookbook_SE 0:de03cbbcd0ff 92 wait_ms(2);
mbed_Cookbook_SE 0:de03cbbcd0ff 93 //EDCtrl->Control = (EDCtrl->Control) | 1; /* Modify control pipe with address 1 */
mbed_Cookbook_SE 0:de03cbbcd0ff 94
mbed_Cookbook_SE 0:de03cbbcd0ff 95 //Update address
mbed_Cookbook_SE 0:de03cbbcd0ff 96 m_pControlEp->updateAddr(m_addr);
mbed_Cookbook_SE 0:de03cbbcd0ff 97 DBG("Ep addr is now %d", m_addr);
mbed_Cookbook_SE 0:de03cbbcd0ff 98 /**/
mbed_Cookbook_SE 0:de03cbbcd0ff 99
mbed_Cookbook_SE 0:de03cbbcd0ff 100 //rc = HOST_GET_DESCRIPTOR(USB_DESCRIPTOR_TYPE_DEVICE, 0, TDBuffer, 17); //Read full device descriptor
mbed_Cookbook_SE 0:de03cbbcd0ff 101 //rc = controlReceive(USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE, GET_DESCRIPTOR,
mbed_Cookbook_SE 0:de03cbbcd0ff 102 // (USB_DESCRIPTOR_TYPE_DEVICE << 8)|(0), 0,
mbed_Cookbook_SE 0:de03cbbcd0ff 103 // m_controlDataBuf, 17);
mbed_Cookbook_SE 0:de03cbbcd0ff 104 uint8_t DeviceDesc[18];
mbed_Cookbook_SE 0:de03cbbcd0ff 105 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_DEVICE, 0, DeviceDesc, sizeof(DeviceDesc));
mbed_Cookbook_SE 0:de03cbbcd0ff 106 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 107 DBG_BYTES("DeviceDescriptor", DeviceDesc, sizeof(DeviceDesc));
mbed_Cookbook_SE 0:de03cbbcd0ff 108 DBG_ASSERT(DeviceDesc[0] == 18);
mbed_Cookbook_SE 0:de03cbbcd0ff 109 DBG_ASSERT(DeviceDesc[1] == 0x01);
mbed_Cookbook_SE 0:de03cbbcd0ff 110 DBG_ASSERT(DeviceDesc[17] == 1); // bNumConfiguration
mbed_Cookbook_SE 0:de03cbbcd0ff 111 if (rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 112 {
mbed_Cookbook_SE 0:de03cbbcd0ff 113 //PRINT_Err(rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 114 return (rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 115 }
mbed_Cookbook_SE 0:de03cbbcd0ff 116
mbed_Cookbook_SE 0:de03cbbcd0ff 117 /*
mbed_Cookbook_SE 0:de03cbbcd0ff 118 rc = SerialCheckVidPid();
mbed_Cookbook_SE 0:de03cbbcd0ff 119 if (rc != OK) {
mbed_Cookbook_SE 0:de03cbbcd0ff 120 PRINT_Err(rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 121 return (rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 122 }
mbed_Cookbook_SE 0:de03cbbcd0ff 123 */
mbed_Cookbook_SE 0:de03cbbcd0ff 124 /**/
mbed_Cookbook_SE 0:de03cbbcd0ff 125 m_DeviceClass = DeviceDesc[4];
mbed_Cookbook_SE 0:de03cbbcd0ff 126 VERBOSE("DeviceClass: %02X\n", m_DeviceClass);
mbed_Cookbook_SE 0:de03cbbcd0ff 127
mbed_Cookbook_SE 0:de03cbbcd0ff 128 m_vid = *((uint16_t*)&DeviceDesc[8]);
mbed_Cookbook_SE 0:de03cbbcd0ff 129 m_pid = *((uint16_t*)&DeviceDesc[10]);
mbed_Cookbook_SE 0:de03cbbcd0ff 130 VERBOSE("Vender: %04X\n", m_vid);
mbed_Cookbook_SE 0:de03cbbcd0ff 131 VERBOSE("Product: %04X\n", m_pid);
mbed_Cookbook_SE 0:de03cbbcd0ff 132 int iManufacture = DeviceDesc[14];
mbed_Cookbook_SE 0:de03cbbcd0ff 133 if (iManufacture) {
mbed_Cookbook_SE 0:de03cbbcd0ff 134 char str[64];
mbed_Cookbook_SE 0:de03cbbcd0ff 135 rc = GetString(iManufacture, str, sizeof(str));
mbed_Cookbook_SE 0:de03cbbcd0ff 136 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 137 VERBOSE("Manufacture: %s\n", str);
mbed_Cookbook_SE 0:de03cbbcd0ff 138 }
mbed_Cookbook_SE 0:de03cbbcd0ff 139 int iProduct = DeviceDesc[15];
mbed_Cookbook_SE 0:de03cbbcd0ff 140 if (iProduct) {
mbed_Cookbook_SE 0:de03cbbcd0ff 141 char str[64];
mbed_Cookbook_SE 0:de03cbbcd0ff 142 rc = GetString(iProduct, str, sizeof(str));
mbed_Cookbook_SE 0:de03cbbcd0ff 143 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 144 VERBOSE("Product: %s\n", str);
mbed_Cookbook_SE 0:de03cbbcd0ff 145 }
mbed_Cookbook_SE 0:de03cbbcd0ff 146 if (DeviceDesc[4] == 0x09) { // Hub
mbed_Cookbook_SE 0:de03cbbcd0ff 147 return hub_init();
mbed_Cookbook_SE 0:de03cbbcd0ff 148 }
mbed_Cookbook_SE 0:de03cbbcd0ff 149
mbed_Cookbook_SE 0:de03cbbcd0ff 150 uint8_t ConfigDesc[9];
mbed_Cookbook_SE 0:de03cbbcd0ff 151 int index = 0;
mbed_Cookbook_SE 0:de03cbbcd0ff 152 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_CONFIGURATION, index, ConfigDesc, sizeof(ConfigDesc));
mbed_Cookbook_SE 0:de03cbbcd0ff 153 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 154 DBG_BYTES("ConfigDescriptor 9bytes", ConfigDesc, sizeof(ConfigDesc));
mbed_Cookbook_SE 0:de03cbbcd0ff 155 DBG_ASSERT(ConfigDesc[0] == 9);
mbed_Cookbook_SE 0:de03cbbcd0ff 156 DBG_ASSERT(ConfigDesc[1] == 0x02);
mbed_Cookbook_SE 0:de03cbbcd0ff 157 int wTotalLength = *((uint16_t*)&ConfigDesc[2]);
mbed_Cookbook_SE 0:de03cbbcd0ff 158 DBG("TotalLength: %d\n", wTotalLength);
mbed_Cookbook_SE 0:de03cbbcd0ff 159 int bConfigValue = ConfigDesc[5];
mbed_Cookbook_SE 0:de03cbbcd0ff 160 DBG_ASSERT(bConfigValue == 1);
mbed_Cookbook_SE 0:de03cbbcd0ff 161 DBG("ConfigValue: %d\n", bConfigValue);
mbed_Cookbook_SE 0:de03cbbcd0ff 162 DBG("MaxPower: %d mA\n", ConfigDesc[8]*2);
mbed_Cookbook_SE 0:de03cbbcd0ff 163
mbed_Cookbook_SE 0:de03cbbcd0ff 164 uint8_t* buf = new uint8_t[wTotalLength];
mbed_Cookbook_SE 0:de03cbbcd0ff 165 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_CONFIGURATION, index, buf, wTotalLength);
mbed_Cookbook_SE 0:de03cbbcd0ff 166 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 167 DBG_ASSERT(ConfigDesc[1] == 0x02);
mbed_Cookbook_SE 0:de03cbbcd0ff 168 int pos = 0;
mbed_Cookbook_SE 0:de03cbbcd0ff 169 while(pos < wTotalLength) {
mbed_Cookbook_SE 0:de03cbbcd0ff 170 DBG_BYTES("", buf+pos, buf[pos]);
mbed_Cookbook_SE 0:de03cbbcd0ff 171 if (buf[pos+1] == 4) { // interface ?
mbed_Cookbook_SE 0:de03cbbcd0ff 172 m_InterfaceClass = buf[pos+5];
mbed_Cookbook_SE 0:de03cbbcd0ff 173 VERBOSE("InterfaceClass: %02X\n", m_InterfaceClass);
mbed_Cookbook_SE 0:de03cbbcd0ff 174 break;
mbed_Cookbook_SE 0:de03cbbcd0ff 175 }
mbed_Cookbook_SE 0:de03cbbcd0ff 176 pos += buf[pos];
mbed_Cookbook_SE 0:de03cbbcd0ff 177 }
mbed_Cookbook_SE 0:de03cbbcd0ff 178 delete[] buf;
mbed_Cookbook_SE 0:de03cbbcd0ff 179
mbed_Cookbook_SE 0:de03cbbcd0ff 180 rc = setConfiguration(1);
mbed_Cookbook_SE 0:de03cbbcd0ff 181 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 182 if (rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 183 {
mbed_Cookbook_SE 0:de03cbbcd0ff 184 // PRINT_Err(rc);
mbed_Cookbook_SE 0:de03cbbcd0ff 185 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 186 }
mbed_Cookbook_SE 0:de03cbbcd0ff 187 wait_ms(100);/* Some devices may require this delay */
mbed_Cookbook_SE 0:de03cbbcd0ff 188
mbed_Cookbook_SE 0:de03cbbcd0ff 189 m_enumerated = true;
mbed_Cookbook_SE 0:de03cbbcd0ff 190 return USBERR_OK;
mbed_Cookbook_SE 0:de03cbbcd0ff 191 }
mbed_Cookbook_SE 0:de03cbbcd0ff 192
mbed_Cookbook_SE 0:de03cbbcd0ff 193 bool UsbDevice::connected()
mbed_Cookbook_SE 0:de03cbbcd0ff 194 {
mbed_Cookbook_SE 0:de03cbbcd0ff 195 return m_connected;
mbed_Cookbook_SE 0:de03cbbcd0ff 196 }
mbed_Cookbook_SE 0:de03cbbcd0ff 197
mbed_Cookbook_SE 0:de03cbbcd0ff 198 bool UsbDevice::enumerated()
mbed_Cookbook_SE 0:de03cbbcd0ff 199 {
mbed_Cookbook_SE 0:de03cbbcd0ff 200 return m_enumerated;
mbed_Cookbook_SE 0:de03cbbcd0ff 201 }
mbed_Cookbook_SE 0:de03cbbcd0ff 202
mbed_Cookbook_SE 0:de03cbbcd0ff 203 int UsbDevice::getPid()
mbed_Cookbook_SE 0:de03cbbcd0ff 204 {
mbed_Cookbook_SE 0:de03cbbcd0ff 205 return m_pid;
mbed_Cookbook_SE 0:de03cbbcd0ff 206 }
mbed_Cookbook_SE 0:de03cbbcd0ff 207
mbed_Cookbook_SE 0:de03cbbcd0ff 208 int UsbDevice::getVid()
mbed_Cookbook_SE 0:de03cbbcd0ff 209 {
mbed_Cookbook_SE 0:de03cbbcd0ff 210 return m_vid;
mbed_Cookbook_SE 0:de03cbbcd0ff 211 }
mbed_Cookbook_SE 0:de03cbbcd0ff 212 #if 0
mbed_Cookbook_SE 0:de03cbbcd0ff 213 UsbErr UsbDevice::getConfigurationDescriptor(int config, uint8_t** pBuf)
mbed_Cookbook_SE 0:de03cbbcd0ff 214 {
mbed_Cookbook_SE 0:de03cbbcd0ff 215 DBG_ASSERT(m_controlDataBuf);
mbed_Cookbook_SE 0:de03cbbcd0ff 216 //For now olny one config
mbed_Cookbook_SE 0:de03cbbcd0ff 217 *pBuf = m_controlDataBuf;
mbed_Cookbook_SE 0:de03cbbcd0ff 218 return USBERR_OK;
mbed_Cookbook_SE 0:de03cbbcd0ff 219 }
mbed_Cookbook_SE 0:de03cbbcd0ff 220
mbed_Cookbook_SE 0:de03cbbcd0ff 221 UsbErr UsbDevice::getInterfaceDescriptor(int config, int item, uint8_t** pBuf)
mbed_Cookbook_SE 0:de03cbbcd0ff 222 {
mbed_Cookbook_SE 0:de03cbbcd0ff 223 DBG_ASSERT(m_controlDataBuf);
mbed_Cookbook_SE 0:de03cbbcd0ff 224 byte* desc_ptr = m_controlDataBuf;
mbed_Cookbook_SE 0:de03cbbcd0ff 225
mbed_Cookbook_SE 0:de03cbbcd0ff 226 /* if (desc_ptr[1] != USB_DESCRIPTOR_TYPE_CONFIGURATION)
mbed_Cookbook_SE 0:de03cbbcd0ff 227 {
mbed_Cookbook_SE 0:de03cbbcd0ff 228 return USBERR_BADCONFIG;
mbed_Cookbook_SE 0:de03cbbcd0ff 229 }*/
mbed_Cookbook_SE 0:de03cbbcd0ff 230 DBG_ASSERT(m_controlDataBuf);
mbed_Cookbook_SE 0:de03cbbcd0ff 231 if(item>=m_controlDataBuf[4])//Interfaces count
mbed_Cookbook_SE 0:de03cbbcd0ff 232 return USBERR_NOTFOUND;
mbed_Cookbook_SE 0:de03cbbcd0ff 233
mbed_Cookbook_SE 0:de03cbbcd0ff 234 desc_ptr += desc_ptr[0];
mbed_Cookbook_SE 0:de03cbbcd0ff 235
mbed_Cookbook_SE 0:de03cbbcd0ff 236 *pBuf = NULL;
mbed_Cookbook_SE 0:de03cbbcd0ff 237
mbed_Cookbook_SE 0:de03cbbcd0ff 238 while (desc_ptr < m_controlDataBuf + *((uint16_t*)&m_controlDataBuf[2]))
mbed_Cookbook_SE 0:de03cbbcd0ff 239 {
mbed_Cookbook_SE 0:de03cbbcd0ff 240
mbed_Cookbook_SE 0:de03cbbcd0ff 241 switch (desc_ptr[1]) {
mbed_Cookbook_SE 0:de03cbbcd0ff 242 case USB_DESCRIPTOR_TYPE_INTERFACE:
mbed_Cookbook_SE 0:de03cbbcd0ff 243 if(desc_ptr[2] == item)
mbed_Cookbook_SE 0:de03cbbcd0ff 244 {
mbed_Cookbook_SE 0:de03cbbcd0ff 245 *pBuf = desc_ptr;
mbed_Cookbook_SE 0:de03cbbcd0ff 246 return USBERR_OK;
mbed_Cookbook_SE 0:de03cbbcd0ff 247 }
mbed_Cookbook_SE 0:de03cbbcd0ff 248 desc_ptr += desc_ptr[0]; // Move to next descriptor start
mbed_Cookbook_SE 0:de03cbbcd0ff 249 break;
mbed_Cookbook_SE 0:de03cbbcd0ff 250 }
mbed_Cookbook_SE 0:de03cbbcd0ff 251
mbed_Cookbook_SE 0:de03cbbcd0ff 252 }
mbed_Cookbook_SE 0:de03cbbcd0ff 253
mbed_Cookbook_SE 0:de03cbbcd0ff 254 if(*pBuf == NULL)
mbed_Cookbook_SE 0:de03cbbcd0ff 255 return USBERR_NOTFOUND;
mbed_Cookbook_SE 0:de03cbbcd0ff 256
mbed_Cookbook_SE 0:de03cbbcd0ff 257 return USBERR_OK;
mbed_Cookbook_SE 0:de03cbbcd0ff 258 }
mbed_Cookbook_SE 0:de03cbbcd0ff 259 #endif
mbed_Cookbook_SE 0:de03cbbcd0ff 260
mbed_Cookbook_SE 0:de03cbbcd0ff 261 UsbErr UsbDevice::setConfiguration(int config)
mbed_Cookbook_SE 0:de03cbbcd0ff 262 {
mbed_Cookbook_SE 0:de03cbbcd0ff 263 DBG("config=%d\n", config);
mbed_Cookbook_SE 0:de03cbbcd0ff 264 DBG_ASSERT(config == 1);
mbed_Cookbook_SE 0:de03cbbcd0ff 265 UsbErr rc = controlSend(
mbed_Cookbook_SE 0:de03cbbcd0ff 266 USB_HOST_TO_DEVICE | USB_RECIPIENT_DEVICE, // 0x00
mbed_Cookbook_SE 0:de03cbbcd0ff 267 SET_CONFIGURATION, config, 0, 0, 0);
mbed_Cookbook_SE 0:de03cbbcd0ff 268 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 269 }
mbed_Cookbook_SE 0:de03cbbcd0ff 270
mbed_Cookbook_SE 0:de03cbbcd0ff 271 UsbErr UsbDevice::controlSend(byte requestType, byte request, word value, word index, const byte* buf, int len)
mbed_Cookbook_SE 0:de03cbbcd0ff 272 {
mbed_Cookbook_SE 0:de03cbbcd0ff 273 UsbErr rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 274 fillControlBuf(requestType, request, value, index, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 275 DBG_ASSERT(m_pControlEp);
mbed_Cookbook_SE 0:de03cbbcd0ff 276 m_pControlEp->setNextToken(TD_SETUP);
mbed_Cookbook_SE 0:de03cbbcd0ff 277 rc = m_pControlEp->transfer(m_controlBuf, 8);
mbed_Cookbook_SE 0:de03cbbcd0ff 278 while(m_pControlEp->status() == USBERR_PROCESSING);
mbed_Cookbook_SE 0:de03cbbcd0ff 279 rc = (UsbErr) MIN(0, m_pControlEp->status());
mbed_Cookbook_SE 0:de03cbbcd0ff 280 if(rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 281 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 282 if(len)
mbed_Cookbook_SE 0:de03cbbcd0ff 283 {
mbed_Cookbook_SE 0:de03cbbcd0ff 284 m_pControlEp->setNextToken(TD_OUT);
mbed_Cookbook_SE 0:de03cbbcd0ff 285 rc = m_pControlEp->transfer((byte*)buf, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 286 while(m_pControlEp->status() == USBERR_PROCESSING);
mbed_Cookbook_SE 0:de03cbbcd0ff 287 rc = (UsbErr) MIN(0, m_pControlEp->status());
mbed_Cookbook_SE 0:de03cbbcd0ff 288 if(rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 289 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 290 }
mbed_Cookbook_SE 0:de03cbbcd0ff 291 m_pControlEp->setNextToken(TD_IN);
mbed_Cookbook_SE 0:de03cbbcd0ff 292 rc = m_pControlEp->transfer(NULL, 0);
mbed_Cookbook_SE 0:de03cbbcd0ff 293 while(m_pControlEp->status() == USBERR_PROCESSING);
mbed_Cookbook_SE 0:de03cbbcd0ff 294 rc = (UsbErr) MIN(0, m_pControlEp->status());
mbed_Cookbook_SE 0:de03cbbcd0ff 295 if(rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 296 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 297 return USBERR_OK;
mbed_Cookbook_SE 0:de03cbbcd0ff 298 }
mbed_Cookbook_SE 0:de03cbbcd0ff 299
mbed_Cookbook_SE 0:de03cbbcd0ff 300 UsbErr UsbDevice::controlReceive(byte requestType, byte request, word value, word index, const byte* buf, int len)
mbed_Cookbook_SE 0:de03cbbcd0ff 301 {
mbed_Cookbook_SE 0:de03cbbcd0ff 302 DBG("buf=%p len=%d\n", buf, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 303 UsbErr rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 304 fillControlBuf(requestType, request, value, index, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 305 DBG_ASSERT(m_pControlEp);
mbed_Cookbook_SE 0:de03cbbcd0ff 306 m_pControlEp->setNextToken(TD_SETUP);
mbed_Cookbook_SE 0:de03cbbcd0ff 307 rc = m_pControlEp->transfer(m_controlBuf, 8);
mbed_Cookbook_SE 0:de03cbbcd0ff 308 while(m_pControlEp->status() == USBERR_PROCESSING);
mbed_Cookbook_SE 0:de03cbbcd0ff 309 rc = (UsbErr) MIN(0, m_pControlEp->status());
mbed_Cookbook_SE 0:de03cbbcd0ff 310 if(rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 311 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 312 if(len)
mbed_Cookbook_SE 0:de03cbbcd0ff 313 {
mbed_Cookbook_SE 0:de03cbbcd0ff 314 m_pControlEp->setNextToken(TD_IN);
mbed_Cookbook_SE 0:de03cbbcd0ff 315 rc = m_pControlEp->transfer( (byte*) buf, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 316 while(m_pControlEp->status() == USBERR_PROCESSING);
mbed_Cookbook_SE 0:de03cbbcd0ff 317 rc = (UsbErr) MIN(0, m_pControlEp->status());
mbed_Cookbook_SE 0:de03cbbcd0ff 318 if(rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 319 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 320 }
mbed_Cookbook_SE 0:de03cbbcd0ff 321 m_pControlEp->setNextToken(TD_OUT);
mbed_Cookbook_SE 0:de03cbbcd0ff 322 rc = m_pControlEp->transfer(NULL, 0);
mbed_Cookbook_SE 0:de03cbbcd0ff 323 while(m_pControlEp->status() == USBERR_PROCESSING);
mbed_Cookbook_SE 0:de03cbbcd0ff 324 rc = (UsbErr) MIN(0, m_pControlEp->status());
mbed_Cookbook_SE 0:de03cbbcd0ff 325 if(rc)
mbed_Cookbook_SE 0:de03cbbcd0ff 326 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 327 return USBERR_OK;
mbed_Cookbook_SE 0:de03cbbcd0ff 328 }
mbed_Cookbook_SE 0:de03cbbcd0ff 329
mbed_Cookbook_SE 0:de03cbbcd0ff 330 UsbErr UsbDevice::GetDescriptor(int type, int index, const byte* buf, int len)
mbed_Cookbook_SE 0:de03cbbcd0ff 331 {
mbed_Cookbook_SE 0:de03cbbcd0ff 332 DBG("type=%02X\n", type);
mbed_Cookbook_SE 0:de03cbbcd0ff 333 return controlReceive(
mbed_Cookbook_SE 0:de03cbbcd0ff 334 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE, GET_DESCRIPTOR,
mbed_Cookbook_SE 0:de03cbbcd0ff 335 (type << 8) |(index), 0, buf, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 336
mbed_Cookbook_SE 0:de03cbbcd0ff 337 }
mbed_Cookbook_SE 0:de03cbbcd0ff 338
mbed_Cookbook_SE 0:de03cbbcd0ff 339 UsbErr UsbDevice::GetString(int index, char* buf, int len)
mbed_Cookbook_SE 0:de03cbbcd0ff 340 {
mbed_Cookbook_SE 0:de03cbbcd0ff 341 DBG("index=%d buf=%p len=%d\n", index, buf, len);
mbed_Cookbook_SE 0:de03cbbcd0ff 342 DBG_ASSERT(index >= 1);
mbed_Cookbook_SE 0:de03cbbcd0ff 343 uint8_t temp[4];
mbed_Cookbook_SE 0:de03cbbcd0ff 344 UsbErr rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 345 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_STRING, 0, temp, sizeof(temp));
mbed_Cookbook_SE 0:de03cbbcd0ff 346 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 347 DBG_BYTES("LANG_ID", temp, sizeof(temp));
mbed_Cookbook_SE 0:de03cbbcd0ff 348 DBG_ASSERT(temp[0] == 4);
mbed_Cookbook_SE 0:de03cbbcd0ff 349 DBG_ASSERT(temp[1] == 0x03);
mbed_Cookbook_SE 0:de03cbbcd0ff 350
mbed_Cookbook_SE 0:de03cbbcd0ff 351 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_STRING, index, temp, 2);
mbed_Cookbook_SE 0:de03cbbcd0ff 352 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 353 DBG_BYTES("length check", temp, 2);
mbed_Cookbook_SE 0:de03cbbcd0ff 354 if (temp[0] == 0x00 && temp[1] == 0x00) { // for pl2303
mbed_Cookbook_SE 0:de03cbbcd0ff 355 if (len > 0) {
mbed_Cookbook_SE 0:de03cbbcd0ff 356 strcpy(buf, "");
mbed_Cookbook_SE 0:de03cbbcd0ff 357 }
mbed_Cookbook_SE 0:de03cbbcd0ff 358 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 359 }
mbed_Cookbook_SE 0:de03cbbcd0ff 360 DBG_ASSERT(temp[1] == 0x03);
mbed_Cookbook_SE 0:de03cbbcd0ff 361 int temp_len = temp[0];
mbed_Cookbook_SE 0:de03cbbcd0ff 362
mbed_Cookbook_SE 0:de03cbbcd0ff 363 uint8_t* temp_buf = new uint8_t[temp_len];
mbed_Cookbook_SE 0:de03cbbcd0ff 364 DBG_ASSERT(temp_buf);
mbed_Cookbook_SE 0:de03cbbcd0ff 365 rc = GetDescriptor(USB_DESCRIPTOR_TYPE_STRING, index, temp_buf, temp_len);
mbed_Cookbook_SE 0:de03cbbcd0ff 366 DBG_ASSERT(rc == USBERR_OK);
mbed_Cookbook_SE 0:de03cbbcd0ff 367 temp_len = temp_buf[0];
mbed_Cookbook_SE 0:de03cbbcd0ff 368 DBG_HEX(temp_buf, temp_len);
mbed_Cookbook_SE 0:de03cbbcd0ff 369 int i = 0;
mbed_Cookbook_SE 0:de03cbbcd0ff 370 for(int pos = 2; pos < temp_len; pos+= 2) {
mbed_Cookbook_SE 0:de03cbbcd0ff 371 buf[i++] = temp_buf[pos];
mbed_Cookbook_SE 0:de03cbbcd0ff 372 DBG_ASSERT(i < len-1);
mbed_Cookbook_SE 0:de03cbbcd0ff 373 }
mbed_Cookbook_SE 0:de03cbbcd0ff 374 buf[i] = '\0';
mbed_Cookbook_SE 0:de03cbbcd0ff 375 delete[] temp_buf;
mbed_Cookbook_SE 0:de03cbbcd0ff 376 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 377 }
mbed_Cookbook_SE 0:de03cbbcd0ff 378
mbed_Cookbook_SE 0:de03cbbcd0ff 379 UsbErr UsbDevice::SetInterfaceAlternate(int interface, int alternate)
mbed_Cookbook_SE 0:de03cbbcd0ff 380 {
mbed_Cookbook_SE 0:de03cbbcd0ff 381 UsbErr rc = controlSend(
mbed_Cookbook_SE 0:de03cbbcd0ff 382 USB_HOST_TO_DEVICE | USB_RECIPIENT_INTERFACE,
mbed_Cookbook_SE 0:de03cbbcd0ff 383 SET_INTERFACE, alternate, interface, NULL, 0);
mbed_Cookbook_SE 0:de03cbbcd0ff 384 return rc;
mbed_Cookbook_SE 0:de03cbbcd0ff 385 }
mbed_Cookbook_SE 0:de03cbbcd0ff 386
mbed_Cookbook_SE 0:de03cbbcd0ff 387 void UsbDevice::fillControlBuf(byte requestType, byte request, word value, word index, int len)
mbed_Cookbook_SE 0:de03cbbcd0ff 388 {
mbed_Cookbook_SE 0:de03cbbcd0ff 389 #ifdef __BIG_ENDIAN
mbed_Cookbook_SE 0:de03cbbcd0ff 390 #error "Must implement BE to LE conv here"
mbed_Cookbook_SE 0:de03cbbcd0ff 391 #endif
mbed_Cookbook_SE 0:de03cbbcd0ff 392 m_controlBuf[0] = requestType;
mbed_Cookbook_SE 0:de03cbbcd0ff 393 m_controlBuf[1] = request;
mbed_Cookbook_SE 0:de03cbbcd0ff 394 //We are in LE so it's fine
mbed_Cookbook_SE 0:de03cbbcd0ff 395 *((word*)&m_controlBuf[2]) = value;
mbed_Cookbook_SE 0:de03cbbcd0ff 396 *((word*)&m_controlBuf[4]) = index;
mbed_Cookbook_SE 0:de03cbbcd0ff 397 *((word*)&m_controlBuf[6]) = (word) len;
mbed_Cookbook_SE 0:de03cbbcd0ff 398 }
mbed_Cookbook_SE 0:de03cbbcd0ff 399
mbed_Cookbook_SE 0:de03cbbcd0ff 400