bool DeviceHandleLibUSB::write(const Transfer& transfer_, uint8_t endpoint_) { int nBytesWritten = 0; if (static_cast<bool>(transfer_) == true) { int result = libusb_bulk_transfer(m_pCurrentDevice, // Device handle endpoint_, // Endpoint const_cast<uint8_t*>(transfer_.data().data()), // Data pointer transfer_.size(), // Size of data &nBytesWritten, // N. of bytes actually written kLibUSBWriteTimeout // Timeout ); if ((LIBUSB_SUCCESS != result) || (nBytesWritten != transfer_.size())) { M_LOG( "[DeviceHandleLibUSB] write: error=" << result << " - transfer size: " << transfer_.size() << " written: " << nBytesWritten); return false; } return true; } return false; }
void DeviceHandleLibUSB::disconnect() { if (m_pCurrentDevice != nullptr) { libusb_close(m_pCurrentDevice); M_LOG("[DeviceHandleLibUSB] disconnect: device closed"); m_pCurrentDevice = nullptr; } }
DeviceHandleLibUSB::~DeviceHandleLibUSB() { M_LOG("[DeviceHandleLibUSB] destructor"); disconnect(); }
CFLOAT M_DECL_FUNC (__catanh) (CFLOAT x) { CFLOAT res; int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); if (__glibc_unlikely (rcls <= FP_INFINITE || icls <= FP_INFINITE)) { if (icls == FP_INFINITE) { __real__ res = M_COPYSIGN (0, __real__ x); __imag__ res = M_COPYSIGN (M_MLIT (M_PI_2), __imag__ x); } else if (rcls == FP_INFINITE || rcls == FP_ZERO) { __real__ res = M_COPYSIGN (0, __real__ x); if (icls >= FP_ZERO) __imag__ res = M_COPYSIGN (M_MLIT (M_PI_2), __imag__ x); else __imag__ res = M_NAN; } else { __real__ res = M_NAN; __imag__ res = M_NAN; } } else if (__glibc_unlikely (rcls == FP_ZERO && icls == FP_ZERO)) { res = x; } else { if (M_FABS (__real__ x) >= 16 / M_EPSILON || M_FABS (__imag__ x) >= 16 / M_EPSILON) { __imag__ res = M_COPYSIGN (M_MLIT (M_PI_2), __imag__ x); if (M_FABS (__imag__ x) <= 1) __real__ res = 1 / __real__ x; else if (M_FABS (__real__ x) <= 1) __real__ res = __real__ x / __imag__ x / __imag__ x; else { FLOAT h = M_HYPOT (__real__ x / 2, __imag__ x / 2); __real__ res = __real__ x / h / h / 4; } } else { if (M_FABS (__real__ x) == 1 && M_FABS (__imag__ x) < M_EPSILON * M_EPSILON) __real__ res = (M_COPYSIGN (M_LIT (0.5), __real__ x) * ((FLOAT) M_MLIT (M_LN2) - M_LOG (M_FABS (__imag__ x)))); else { FLOAT i2 = 0; if (M_FABS (__imag__ x) >= M_EPSILON * M_EPSILON) i2 = __imag__ x * __imag__ x; FLOAT num = 1 + __real__ x; num = i2 + num * num; FLOAT den = 1 - __real__ x; den = i2 + den * den; FLOAT f = num / den; if (f < M_LIT (0.5)) __real__ res = M_LIT (0.25) * M_LOG (f); else { num = 4 * __real__ x; __real__ res = M_LIT (0.25) * M_LOG1P (num / den); } } FLOAT absx, absy, den; absx = M_FABS (__real__ x); absy = M_FABS (__imag__ x); if (absx < absy) { FLOAT t = absx; absx = absy; absy = t; } if (absy < M_EPSILON / 2) { den = (1 - absx) * (1 + absx); if (den == 0) den = 0; } else if (absx >= 1) den = (1 - absx) * (1 + absx) - absy * absy; else if (absx >= M_LIT (0.75) || absy >= M_LIT (0.5)) den = -M_SUF (__x2y2m1) (absx, absy); else den = (1 - absx) * (1 + absx) - absy * absy; __imag__ res = M_LIT (0.5) * M_ATAN2 (2 * __imag__ x, den); } math_check_force_underflow_complex (res); } return res; }
CFLOAT M_DECL_FUNC (__clog) (CFLOAT x) { CFLOAT result; int rcls = fpclassify (__real__ x); int icls = fpclassify (__imag__ x); if (__glibc_unlikely (rcls == FP_ZERO && icls == FP_ZERO)) { /* Real and imaginary part are 0.0. */ __imag__ result = signbit (__real__ x) ? (FLOAT) M_MLIT (M_PI) : 0; __imag__ result = M_COPYSIGN (__imag__ result, __imag__ x); /* Yes, the following line raises an exception. */ __real__ result = -1 / M_FABS (__real__ x); } else if (__glibc_likely (rcls != FP_NAN && icls != FP_NAN)) { /* Neither real nor imaginary part is NaN. */ FLOAT absx = M_FABS (__real__ x), absy = M_FABS (__imag__ x); int scale = 0; if (absx < absy) { FLOAT t = absx; absx = absy; absy = t; } if (absx > M_MAX / 2) { scale = -1; absx = M_SCALBN (absx, scale); absy = (absy >= M_MIN * 2 ? M_SCALBN (absy, scale) : 0); } else if (absx < M_MIN && absy < M_MIN) { scale = M_MANT_DIG; absx = M_SCALBN (absx, scale); absy = M_SCALBN (absy, scale); } if (absx == 1 && scale == 0) { __real__ result = M_LOG1P (absy * absy) / 2; math_check_force_underflow_nonneg (__real__ result); } else if (absx > 1 && absx < 2 && absy < 1 && scale == 0) { FLOAT d2m1 = (absx - 1) * (absx + 1); if (absy >= M_EPSILON) d2m1 += absy * absy; __real__ result = M_LOG1P (d2m1) / 2; } else if (absx < 1 && absx >= M_LIT (0.5) && absy < M_EPSILON / 2 && scale == 0) { FLOAT d2m1 = (absx - 1) * (absx + 1); __real__ result = M_LOG1P (d2m1) / 2; } else if (absx < 1 && absx >= M_LIT (0.5) && scale == 0 && absx * absx + absy * absy >= M_LIT (0.5)) { FLOAT d2m1 = M_SUF (__x2y2m1) (absx, absy); __real__ result = M_LOG1P (d2m1) / 2; } else { FLOAT d = M_HYPOT (absx, absy); __real__ result = M_LOG (d) - scale * (FLOAT) M_MLIT (M_LN2); } __imag__ result = M_ATAN2 (__imag__ x, __real__ x); } else { __imag__ result = M_NAN; if (rcls == FP_INFINITE || icls == FP_INFINITE) /* Real or imaginary part is infinite. */ __real__ result = M_HUGE_VAL; else __real__ result = M_NAN; } return result; }
uint32_t DeviceHandleSAM3XE::Init(uint32_t parent_, uint32_t port_, uint32_t lowspeed_) { uint8_t buf[sizeof(USB_DEVICE_DESCRIPTOR)]; uint32_t retCode = 0; UsbDevice* pDevice = nullptr; EpInfo* pEpInfo_old = nullptr; uint32_t nOfConfigurations = 0; if (m_deviceAddress) { return USB_ERROR_CLASS_INSTANCE_ALREADY_IN_USE; } AddressPool& addrPool = m_pUsb->GetAddressPool(); pDevice = addrPool.GetUsbDevicePtr(0); if (!pDevice) { return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL; } else if (!pDevice->epinfo) { return USB_ERROR_EPINFO_IS_NULL; } pEpInfo_old = pDevice->epinfo; pDevice->epinfo = m_epInfo; pDevice->lowspeed = lowspeed_; retCode = m_pUsb->getDevDescr(0, 0, sizeof(USB_DEVICE_DESCRIPTOR), static_cast<uint8_t*>(buf)); pDevice->epinfo = pEpInfo_old; if (retCode != 0) { M_LOG("ERROR (" << retCode << "): Failed to get device descriptor"); Release(); return retCode; } m_deviceAddress = addrPool.AllocAddress(parent_, false, port_); // Extract Max Packet Size from device descriptor m_epInfo[0].maxPktSize = (uint8_t)((USB_DEVICE_DESCRIPTOR*)buf)->bMaxPacketSize0; // Assign new address to the device retCode = m_pUsb->setAddr(0, 0, m_deviceAddress); if (retCode) { pDevice->lowspeed = false; addrPool.FreeAddress(m_deviceAddress); m_deviceAddress = 0; M_LOG("ERROR (" << retCode << "): setAddr failed"); return retCode; } M_LOG("Device address is now " << m_deviceAddress); pDevice->lowspeed = false; // get pointer to assigned address record pDevice = addrPool.GetUsbDevicePtr(m_deviceAddress); if (!pDevice) { m_deviceAddress = 0; M_LOG("ERROR: address not found in pool"); return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL; } pDevice->lowspeed = lowspeed_; // Assign epInfo to epinfo pointer - only EP0 is known retCode = m_pUsb->setEpInfoEntry(m_deviceAddress, 1, m_epInfo); if (retCode) { m_deviceAddress = 0; M_LOG("ERROR (" << retCode << "): setEpInfoEntry failed"); return retCode; } // Check if ADK device is already in accessory mode; if yes, configure and exit if (((USB_DEVICE_DESCRIPTOR*)buf)->idVendor == ADK_VID && (((USB_DEVICE_DESCRIPTOR*)buf)->idProduct == ADK_PID || ((USB_DEVICE_DESCRIPTOR*)buf)->idProduct == ADB_PID)) { nOfConfigurations = ((USB_DEVICE_DESCRIPTOR*)buf)->bNumConfigurations; M_LOG("Thid device has a total of " << nOfConfigurations << " configurations"); for (uint32_t i = 0; i < nOfConfigurations; ++i) { ConfigDescParser<0, 0, 0, 0> confDescrParser(this); delay(1); retCode = m_pUsb->getConfDescr(m_deviceAddress, 0, i, &confDescrParser); if (retCode) { M_LOG("ERROR (" << retCode << "): Failed to get config descriptor for configuration n. "); Release(); return retCode; } if (bNumEP > 2) { break; } } if (bNumEP == 3) { // Assign epInfo to epinfo pointer - this time all 3 endpoins retCode = m_pUsb->setEpInfoEntry(m_deviceAddress, 3, epInfo); if (retCode) { goto FailSetDevTblEntry; } } // Set Configuration Value retCode = m_pUsb->setConf(m_deviceAddress, 0, bConfNum); if (retCode) { goto FailSetConf; } TRACE_USBHOST(printf("ADK::Init : ADK device configured successfully\r\n");)