mirror of
https://github.com/fhgwright/SCSI2SD.git
synced 2025-01-09 04:30:29 +00:00
95b519789b
Also fixes a problem with SD card initialisation not setting the clock back to normal on an error condition. The next initialisation attempt ends up running the card at a very slow rate.
425 lines
8.9 KiB
C++
425 lines
8.9 KiB
C++
// Copyright (C) 2014 Michael McMaster <michael@codesrc.com>
|
|
//
|
|
// This file is part of SCSI2SD.
|
|
//
|
|
// SCSI2SD is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// SCSI2SD is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with SCSI2SD. If not, see <http://www.gnu.org/licenses/>.
|
|
#include "SCSI2SD_HID.hh"
|
|
#include "scsi2sd.h"
|
|
#include "hidpacket.h"
|
|
|
|
// For compilers that support precompilation, includes "wx/wx.h".
|
|
#include <wx/wxprec.h>
|
|
#ifndef WX_PRECOMP
|
|
#include <wx/wx.h>
|
|
#endif
|
|
|
|
#include <wx/utils.h>
|
|
|
|
#include <cassert>
|
|
#include <stdexcept>
|
|
#include <sstream>
|
|
|
|
#include <iostream>
|
|
#include <string.h> // memcpy
|
|
|
|
using namespace SCSI2SD;
|
|
|
|
HID::HID(hid_device_info* hidInfo) :
|
|
myHidInfo(hidInfo),
|
|
myConfigHandle(NULL),
|
|
myDebugHandle(NULL),
|
|
myFirmwareVersion(0),
|
|
mySDCapacity(0)
|
|
{
|
|
|
|
// hidInfo->interface_number not supported on mac, and interfaces
|
|
// are enumerated in a random order. :-(
|
|
// We rely on the watchdog value of the debug interface changing on each
|
|
// read to differentiate the interfaces.
|
|
try
|
|
{
|
|
while (hidInfo && !(myConfigHandle && myDebugHandle))
|
|
{
|
|
std::stringstream msg;
|
|
msg << "Error opening HID device " << hidInfo->path << std::endl;
|
|
|
|
if ((hidInfo->interface_number == CONFIG_INTERFACE) ||
|
|
(hidInfo->usage_page == 0xFF00))
|
|
{
|
|
myConfigHandle = hid_open_path(hidInfo->path);
|
|
if (!myConfigHandle) throw std::runtime_error(msg.str());
|
|
|
|
hidInfo = hidInfo->next;
|
|
}
|
|
else if ((hidInfo->interface_number == DEBUG_INTERFACE) ||
|
|
(hidInfo->usage_page == 0xFF01))
|
|
{
|
|
myDebugHandle = hid_open_path(hidInfo->path);
|
|
if (!myDebugHandle) throw std::runtime_error(msg.str());
|
|
readDebugData();
|
|
hidInfo = hidInfo->next;
|
|
}
|
|
else if (hidInfo->interface_number == -1)
|
|
{
|
|
// hidInfo->interface_number not supported on mac, and
|
|
// interfaces are enumerated in a random order. :-(
|
|
// We rely on the watchdog value of the debug interface
|
|
// changing on each read to differentiate the interfaces.
|
|
// Not necessary since firmware 3.5.2 as the usage_page can
|
|
// be used instead.
|
|
hid_device* dev = hid_open_path(hidInfo->path);
|
|
if (!dev)
|
|
{
|
|
throw std::runtime_error(msg.str());
|
|
}
|
|
|
|
uint8_t buf[HID_PACKET_SIZE];
|
|
int watchVal = -1;
|
|
int configIntFound = 1;
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
buf[0] = 0; // report id
|
|
hid_read_timeout(dev, buf, HID_PACKET_SIZE, HID_TIMEOUT_MS);
|
|
if (watchVal == -1) watchVal = buf[25];
|
|
configIntFound = configIntFound && (buf[25] == watchVal);
|
|
}
|
|
|
|
if (configIntFound)
|
|
{
|
|
myConfigHandle = dev;
|
|
}
|
|
else
|
|
{
|
|
myDebugHandle = dev;
|
|
readDebugData();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (std::runtime_error& e)
|
|
{
|
|
destroy();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
void
|
|
HID::destroy()
|
|
{
|
|
if (myConfigHandle)
|
|
{
|
|
hid_close(myConfigHandle);
|
|
myConfigHandle = NULL;
|
|
}
|
|
if (myDebugHandle)
|
|
{
|
|
hid_close(myDebugHandle);
|
|
myDebugHandle = NULL;
|
|
}
|
|
|
|
hid_free_enumeration(myHidInfo);
|
|
myHidInfo = NULL;
|
|
}
|
|
|
|
HID::~HID()
|
|
{
|
|
destroy();
|
|
}
|
|
|
|
HID*
|
|
HID::Open()
|
|
{
|
|
hid_device_info* dev = hid_enumerate(VENDOR_ID, PRODUCT_ID);
|
|
if (dev)
|
|
{
|
|
return new HID(dev);
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
HID::enterBootloader()
|
|
{
|
|
// Reboot commands added in firmware 3.5
|
|
if (!myDebugHandle)
|
|
{
|
|
throw std::runtime_error(
|
|
"Cannot enter SCSI2SD bootloader: debug interface not found");
|
|
}
|
|
else if (myFirmwareVersion == 0)
|
|
{
|
|
throw std::runtime_error(
|
|
"Cannot enter SCSI2SD bootloader: old firmware version running.\n"
|
|
"The SCSI2SD board cannot reset itself. Please disconnect and \n"
|
|
"reconnect the USB cable.\n");
|
|
}
|
|
else
|
|
{
|
|
uint8_t hidBuf[HID_PACKET_SIZE + 1] =
|
|
{
|
|
0x00, // Report ID;
|
|
0x01 // Reboot command
|
|
// 63 bytes unused.
|
|
};
|
|
|
|
int result = hid_write(myDebugHandle, hidBuf, sizeof(hidBuf));
|
|
if (result <= 0)
|
|
{
|
|
const wchar_t* err = hid_error(myDebugHandle);
|
|
std::stringstream ss;
|
|
ss << "USB HID write failure: " << err;
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
HID::readFlashRow(int array, int row, std::vector<uint8_t>& out)
|
|
{
|
|
std::vector<uint8_t> cmd
|
|
{
|
|
CONFIG_READFLASH,
|
|
static_cast<uint8_t>(array),
|
|
static_cast<uint8_t>(row)
|
|
};
|
|
sendHIDPacket(cmd, out, HIDPACKET_MAX_LEN / 62);
|
|
}
|
|
|
|
void
|
|
HID::writeFlashRow(int array, int row, const std::vector<uint8_t>& in)
|
|
{
|
|
std::vector<uint8_t> cmd;
|
|
cmd.push_back(CONFIG_WRITEFLASH);
|
|
cmd.insert(cmd.end(), in.begin(), in.end());
|
|
cmd.push_back(static_cast<uint8_t>(array));
|
|
cmd.push_back(static_cast<uint8_t>(row));
|
|
std::vector<uint8_t> out;
|
|
sendHIDPacket(cmd, out, 1);
|
|
if ((out.size() < 1) || (out[0] != CONFIG_STATUS_GOOD))
|
|
{
|
|
std::stringstream ss;
|
|
ss << "Error writing flash " << array << "/" << row;
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
}
|
|
|
|
bool
|
|
HID::readSCSIDebugInfo(std::vector<uint8_t>& buf)
|
|
{
|
|
buf[0] = 0; // report id
|
|
hid_set_nonblocking(myDebugHandle, 1);
|
|
int result =
|
|
hid_read_timeout(
|
|
myDebugHandle,
|
|
&buf[0],
|
|
HID_PACKET_SIZE,
|
|
HID_TIMEOUT_MS);
|
|
hid_set_nonblocking(myDebugHandle, 0);
|
|
|
|
if (result <= 0)
|
|
{
|
|
const wchar_t* err = hid_error(myDebugHandle);
|
|
std::stringstream ss;
|
|
ss << "USB HID read failure: " << err;
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
return result > 0;
|
|
}
|
|
|
|
|
|
void
|
|
HID::readHID(uint8_t* buffer, size_t len)
|
|
{
|
|
assert(len >= 0);
|
|
buffer[0] = 0; // report id
|
|
|
|
int result = -1;
|
|
for (int retry = 0; retry < 3 && result <= 0; ++retry)
|
|
{
|
|
result = hid_read_timeout(myConfigHandle, buffer, len, HID_TIMEOUT_MS);
|
|
}
|
|
|
|
if (result < 0)
|
|
{
|
|
const wchar_t* err = hid_error(myConfigHandle);
|
|
std::stringstream ss;
|
|
ss << "USB HID read failure: " << err;
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
}
|
|
|
|
void
|
|
HID::readDebugData()
|
|
{
|
|
uint8_t buf[HID_PACKET_SIZE];
|
|
buf[0] = 0; // report id
|
|
int result =
|
|
hid_read_timeout(
|
|
myDebugHandle,
|
|
buf,
|
|
HID_PACKET_SIZE,
|
|
HID_TIMEOUT_MS);
|
|
|
|
if (result <= 0)
|
|
{
|
|
const wchar_t* err = hid_error(myDebugHandle);
|
|
std::stringstream ss;
|
|
ss << "USB HID read failure: " << err;
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
myFirmwareVersion = (((uint16_t)buf[62]) << 8) | buf[63];
|
|
|
|
mySDCapacity =
|
|
(((uint32_t)buf[58]) << 24) |
|
|
(((uint32_t)buf[59]) << 16) |
|
|
(((uint32_t)buf[60]) << 8) |
|
|
((uint32_t)buf[61]);
|
|
}
|
|
|
|
std::string
|
|
HID::getFirmwareVersionStr() const
|
|
{
|
|
if (myFirmwareVersion == 0)
|
|
{
|
|
return "Unknown (3.0 - 3.4)";
|
|
}
|
|
else
|
|
{
|
|
std::stringstream ver;
|
|
ver << std::hex <<
|
|
(myFirmwareVersion >> 8) <<
|
|
'.' << ((myFirmwareVersion & 0xF0) >> 4);
|
|
|
|
int rev = myFirmwareVersion & 0xF;
|
|
if (rev)
|
|
{
|
|
ver << "." << rev;
|
|
}
|
|
return ver.str();
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
HID::ping()
|
|
{
|
|
std::vector<uint8_t> cmd { CONFIG_PING };
|
|
std::vector<uint8_t> out;
|
|
try
|
|
{
|
|
sendHIDPacket(cmd, out, 1);
|
|
}
|
|
catch (std::runtime_error& e)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return (out.size() >= 1) && (out[0] == CONFIG_STATUS_GOOD);
|
|
}
|
|
|
|
std::vector<uint8_t>
|
|
HID::getSD_CSD()
|
|
{
|
|
std::vector<uint8_t> cmd { CONFIG_SDINFO };
|
|
std::vector<uint8_t> out;
|
|
try
|
|
{
|
|
sendHIDPacket(cmd, out, 1);
|
|
}
|
|
catch (std::runtime_error& e)
|
|
{
|
|
return std::vector<uint8_t>(16);
|
|
}
|
|
|
|
out.resize(16);
|
|
return out;
|
|
}
|
|
|
|
std::vector<uint8_t>
|
|
HID::getSD_CID()
|
|
{
|
|
std::vector<uint8_t> cmd { CONFIG_SDINFO };
|
|
std::vector<uint8_t> out;
|
|
try
|
|
{
|
|
sendHIDPacket(cmd, out, 1);
|
|
}
|
|
catch (std::runtime_error& e)
|
|
{
|
|
return std::vector<uint8_t>(16);
|
|
}
|
|
|
|
std::vector<uint8_t> result(16);
|
|
for (size_t i = 0; i < 16; ++i) result[i] = out[16 + i];
|
|
return result;
|
|
}
|
|
|
|
void
|
|
HID::sendHIDPacket(
|
|
const std::vector<uint8_t>& cmd,
|
|
std::vector<uint8_t>& out,
|
|
size_t responseLength)
|
|
{
|
|
assert(cmd.size() <= HIDPACKET_MAX_LEN);
|
|
hidPacket_send(&cmd[0], cmd.size());
|
|
|
|
uint8_t hidBuf[HID_PACKET_SIZE];
|
|
const uint8_t* chunk = hidPacket_getHIDBytes(hidBuf);
|
|
|
|
while (chunk)
|
|
{
|
|
uint8_t reportBuf[HID_PACKET_SIZE + 1] = { 0x00 }; // Report ID
|
|
memcpy(&reportBuf[1], chunk, HID_PACKET_SIZE);
|
|
int result = -1;
|
|
for (int retry = 0; retry < 10 && result <= 0; ++retry)
|
|
{
|
|
result = hid_write(myConfigHandle, reportBuf, sizeof(reportBuf));
|
|
}
|
|
|
|
if (result <= 0)
|
|
{
|
|
const wchar_t* err = hid_error(myConfigHandle);
|
|
std::stringstream ss;
|
|
ss << "USB HID write failure: " << err;
|
|
throw std::runtime_error(ss.str());
|
|
}
|
|
chunk = hidPacket_getHIDBytes(hidBuf);
|
|
}
|
|
|
|
const uint8_t* resp = NULL;
|
|
size_t respLen;
|
|
resp = hidPacket_getPacket(&respLen);
|
|
|
|
for (unsigned int retry = 0; retry < responseLength * 2 && !resp; ++retry)
|
|
{
|
|
readHID(hidBuf, sizeof(hidBuf)); // Will block
|
|
hidPacket_recv(hidBuf, HID_PACKET_SIZE);
|
|
resp = hidPacket_getPacket(&respLen);
|
|
}
|
|
|
|
if (!resp)
|
|
{
|
|
throw std::runtime_error("SCSI2SD config protocol error");
|
|
}
|
|
out.insert(
|
|
out.end(),
|
|
resp,
|
|
resp + respLen);
|
|
}
|
|
|
|
|