|
|
@@ -1,1204 +0,0 @@
|
|
|
-/*
|
|
|
- * Copyright 2012 Andrew Smith
|
|
|
- *
|
|
|
- * This program 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. See COPYING for more details.
|
|
|
- */
|
|
|
-
|
|
|
-#include "config.h"
|
|
|
-
|
|
|
-#include <stdint.h>
|
|
|
-#include <stdbool.h>
|
|
|
-
|
|
|
-#include "logging.h"
|
|
|
-#include "miner.h"
|
|
|
-#include "usbutils.h"
|
|
|
-
|
|
|
-#ifdef USE_ICARUS
|
|
|
-#define DRV_ICARUS 1
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_BITFORCE
|
|
|
-#define DRV_BITFORCE 2
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_MODMINER
|
|
|
-#define DRV_MODMINER 3
|
|
|
-#endif
|
|
|
-
|
|
|
-#define DRV_LAST -1
|
|
|
-
|
|
|
-#define USB_CONFIG 1
|
|
|
-
|
|
|
-#define EPI(x) (LIBUSB_ENDPOINT_IN | (unsigned char)(x))
|
|
|
-#define EPO(x) (LIBUSB_ENDPOINT_OUT | (unsigned char)(x))
|
|
|
-
|
|
|
-#ifdef WIN32
|
|
|
-#define MODMINER_TIMEOUT_MS 200
|
|
|
-#else
|
|
|
-#define MODMINER_TIMEOUT_MS 100
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_MODMINER
|
|
|
-static struct usb_endpoints mmq_eps[] = {
|
|
|
- { LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(3), 0 },
|
|
|
- { LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(3), 0 }
|
|
|
-};
|
|
|
-#endif
|
|
|
-
|
|
|
-// TODO: Add support for (at least) Interrupt endpoints
|
|
|
-static struct usb_find_devices find_dev[] = {
|
|
|
-/*
|
|
|
-#ifdef USE_ICARUS
|
|
|
- { DRV_ICARUS, "ICA", 0x067b, 0x0230, true, EPI(3), EPO(2), 1 },
|
|
|
- { DRV_ICARUS, "LOT", 0x0403, 0x6001, false, EPI(0), EPO(0), 1 },
|
|
|
- { DRV_ICARUS, "CM1", 0x067b, 0x0230, false, EPI(0), EPO(0), 1 },
|
|
|
-#endif
|
|
|
-#ifdef USE_BITFORCE
|
|
|
- { DRV_BITFORCE, "BFL", 0x0403, 0x6014, true, EPI(1), EPO(2), 1 },
|
|
|
-#endif
|
|
|
-*/
|
|
|
-#ifdef USE_MODMINER
|
|
|
- {
|
|
|
- .drv = DRV_MODMINER,
|
|
|
- .name = "MMQ",
|
|
|
- .idVendor = 0x1fc9,
|
|
|
- .idProduct = 0x0003,
|
|
|
- .config = 1,
|
|
|
- .interface = 1,
|
|
|
- .timeout = MODMINER_TIMEOUT_MS,
|
|
|
- .epcount = ARRAY_SIZE(mmq_eps),
|
|
|
- .eps = mmq_eps },
|
|
|
-#endif
|
|
|
- { DRV_LAST, NULL, 0, 0, 0, 0, 0, 0, NULL }
|
|
|
-};
|
|
|
-
|
|
|
-#ifdef USE_BITFORCE
|
|
|
-extern struct device_api bitforce_api;
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_ICARUS
|
|
|
-extern struct device_api icarus_api;
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_MODMINER
|
|
|
-extern struct device_api modminer_api;
|
|
|
-#endif
|
|
|
-
|
|
|
-/*
|
|
|
- * Our own internal list of used USB devices
|
|
|
- * So two drivers or a single driver searching
|
|
|
- * can't touch the same device during detection
|
|
|
- */
|
|
|
-struct usb_list {
|
|
|
- uint8_t bus_number;
|
|
|
- uint8_t device_address;
|
|
|
- uint8_t filler[2];
|
|
|
- struct usb_list *prev;
|
|
|
- struct usb_list *next;
|
|
|
-};
|
|
|
-
|
|
|
-#define STRBUFLEN 256
|
|
|
-static const char *BLANK = "";
|
|
|
-
|
|
|
-static pthread_mutex_t *list_lock = NULL;
|
|
|
-static struct usb_list *usb_head = NULL;
|
|
|
-
|
|
|
-struct cg_usb_stats_item {
|
|
|
- uint64_t count;
|
|
|
- double total_delay;
|
|
|
- double min_delay;
|
|
|
- double max_delay;
|
|
|
- struct timeval first;
|
|
|
- struct timeval last;
|
|
|
-};
|
|
|
-
|
|
|
-#define CMD_CMD 0
|
|
|
-#define CMD_TIMEOUT 1
|
|
|
-#define CMD_ERROR 2
|
|
|
-
|
|
|
-struct cg_usb_stats_details {
|
|
|
- int seq;
|
|
|
- struct cg_usb_stats_item item[CMD_ERROR+1];
|
|
|
-};
|
|
|
-
|
|
|
-struct cg_usb_stats {
|
|
|
- char *name;
|
|
|
- int device_id;
|
|
|
- struct cg_usb_stats_details *details;
|
|
|
-};
|
|
|
-
|
|
|
-#define SEQ0 0
|
|
|
-#define SEQ1 1
|
|
|
-
|
|
|
-static struct cg_usb_stats *usb_stats = NULL;
|
|
|
-static int next_stat = 0;
|
|
|
-
|
|
|
-static const char **usb_commands;
|
|
|
-
|
|
|
-static const char *C_PING_S = "Ping";
|
|
|
-static const char *C_CLEAR_S = "Clear";
|
|
|
-static const char *C_REQUESTVERSION_S = "RequestVersion";
|
|
|
-static const char *C_GETVERSION_S = "GetVersion";
|
|
|
-static const char *C_REQUESTFPGACOUNT_S = "RequestFPGACount";
|
|
|
-static const char *C_GETFPGACOUNT_S = "GetFPGACount";
|
|
|
-static const char *C_STARTPROGRAM_S = "StartProgram";
|
|
|
-static const char *C_STARTPROGRAMSTATUS_S = "StartProgramStatus";
|
|
|
-static const char *C_PROGRAM_S = "Program";
|
|
|
-static const char *C_PROGRAMSTATUS_S = "ProgramStatus";
|
|
|
-static const char *C_PROGRAMSTATUS2_S = "ProgramStatus2";
|
|
|
-static const char *C_FINALPROGRAMSTATUS_S = "FinalProgramStatus";
|
|
|
-static const char *C_SETCLOCK_S = "SetClock";
|
|
|
-static const char *C_REPLYSETCLOCK_S = "ReplySetClock";
|
|
|
-static const char *C_REQUESTUSERCODE_S = "RequestUserCode";
|
|
|
-static const char *C_GETUSERCODE_S = "GetUserCode";
|
|
|
-static const char *C_REQUESTTEMPERATURE_S = "RequestTemperature";
|
|
|
-static const char *C_GETTEMPERATURE_S = "GetTemperature";
|
|
|
-static const char *C_SENDWORK_S = "SendWork";
|
|
|
-static const char *C_SENDWORKSTATUS_S = "SendWorkStatus";
|
|
|
-static const char *C_REQUESTWORKSTATUS_S = "RequestWorkStatus";
|
|
|
-static const char *C_GETWORKSTATUS_S = "GetWorkStatus";
|
|
|
-
|
|
|
-#ifdef EOL
|
|
|
-#undef EOL
|
|
|
-#endif
|
|
|
-#define EOL "\n"
|
|
|
-
|
|
|
-static const char *DESDEV = "Device";
|
|
|
-static const char *DESCON = "Config";
|
|
|
-static const char *DESSTR = "String";
|
|
|
-static const char *DESINT = "Interface";
|
|
|
-static const char *DESEP = "Endpoint";
|
|
|
-static const char *DESHID = "HID";
|
|
|
-static const char *DESRPT = "Report";
|
|
|
-static const char *DESPHY = "Physical";
|
|
|
-static const char *DESHUB = "Hub";
|
|
|
-
|
|
|
-static const char *EPIN = "In: ";
|
|
|
-static const char *EPOUT = "Out: ";
|
|
|
-static const char *EPX = "?: ";
|
|
|
-
|
|
|
-static const char *CONTROL = "Control";
|
|
|
-static const char *ISOCHRONOUS_X = "Isochronous+?";
|
|
|
-static const char *ISOCHRONOUS_N_X = "Isochronous+None+?";
|
|
|
-static const char *ISOCHRONOUS_N_D = "Isochronous+None+Data";
|
|
|
-static const char *ISOCHRONOUS_N_F = "Isochronous+None+Feedback";
|
|
|
-static const char *ISOCHRONOUS_N_I = "Isochronous+None+Implicit";
|
|
|
-static const char *ISOCHRONOUS_A_X = "Isochronous+Async+?";
|
|
|
-static const char *ISOCHRONOUS_A_D = "Isochronous+Async+Data";
|
|
|
-static const char *ISOCHRONOUS_A_F = "Isochronous+Async+Feedback";
|
|
|
-static const char *ISOCHRONOUS_A_I = "Isochronous+Async+Implicit";
|
|
|
-static const char *ISOCHRONOUS_D_X = "Isochronous+Adaptive+?";
|
|
|
-static const char *ISOCHRONOUS_D_D = "Isochronous+Adaptive+Data";
|
|
|
-static const char *ISOCHRONOUS_D_F = "Isochronous+Adaptive+Feedback";
|
|
|
-static const char *ISOCHRONOUS_D_I = "Isochronous+Adaptive+Implicit";
|
|
|
-static const char *ISOCHRONOUS_S_X = "Isochronous+Sync+?";
|
|
|
-static const char *ISOCHRONOUS_S_D = "Isochronous+Sync+Data";
|
|
|
-static const char *ISOCHRONOUS_S_F = "Isochronous+Sync+Feedback";
|
|
|
-static const char *ISOCHRONOUS_S_I = "Isochronous+Sync+Implicit";
|
|
|
-static const char *BULK = "Bulk";
|
|
|
-static const char *INTERRUPT = "Interrupt";
|
|
|
-static const char *UNKNOWN = "Unknown";
|
|
|
-
|
|
|
-static const char *destype(uint8_t bDescriptorType)
|
|
|
-{
|
|
|
- switch (bDescriptorType) {
|
|
|
- case LIBUSB_DT_DEVICE:
|
|
|
- return DESDEV;
|
|
|
- case LIBUSB_DT_CONFIG:
|
|
|
- return DESCON;
|
|
|
- case LIBUSB_DT_STRING:
|
|
|
- return DESSTR;
|
|
|
- case LIBUSB_DT_INTERFACE:
|
|
|
- return DESINT;
|
|
|
- case LIBUSB_DT_ENDPOINT:
|
|
|
- return DESEP;
|
|
|
- case LIBUSB_DT_HID:
|
|
|
- return DESHID;
|
|
|
- case LIBUSB_DT_REPORT:
|
|
|
- return DESRPT;
|
|
|
- case LIBUSB_DT_PHYSICAL:
|
|
|
- return DESPHY;
|
|
|
- case LIBUSB_DT_HUB:
|
|
|
- return DESHUB;
|
|
|
- }
|
|
|
- return UNKNOWN;
|
|
|
-}
|
|
|
-
|
|
|
-static const char *epdir(uint8_t bEndpointAddress)
|
|
|
-{
|
|
|
- switch (bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) {
|
|
|
- case LIBUSB_ENDPOINT_IN:
|
|
|
- return EPIN;
|
|
|
- case LIBUSB_ENDPOINT_OUT:
|
|
|
- return EPOUT;
|
|
|
- }
|
|
|
- return EPX;
|
|
|
-}
|
|
|
-
|
|
|
-static const char *epatt(uint8_t bmAttributes)
|
|
|
-{
|
|
|
- switch(bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) {
|
|
|
- case LIBUSB_TRANSFER_TYPE_CONTROL:
|
|
|
- return CONTROL;
|
|
|
- case LIBUSB_TRANSFER_TYPE_BULK:
|
|
|
- return BULK;
|
|
|
- case LIBUSB_TRANSFER_TYPE_INTERRUPT:
|
|
|
- return INTERRUPT;
|
|
|
- case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
|
|
|
- switch(bmAttributes & LIBUSB_ISO_SYNC_TYPE_MASK) {
|
|
|
- case LIBUSB_ISO_SYNC_TYPE_NONE:
|
|
|
- switch(bmAttributes & LIBUSB_ISO_USAGE_TYPE_MASK) {
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_DATA:
|
|
|
- return ISOCHRONOUS_N_D;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_FEEDBACK:
|
|
|
- return ISOCHRONOUS_N_F;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_IMPLICIT:
|
|
|
- return ISOCHRONOUS_N_I;
|
|
|
- }
|
|
|
- return ISOCHRONOUS_N_X;
|
|
|
- case LIBUSB_ISO_SYNC_TYPE_ASYNC:
|
|
|
- switch(bmAttributes & LIBUSB_ISO_USAGE_TYPE_MASK) {
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_DATA:
|
|
|
- return ISOCHRONOUS_A_D;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_FEEDBACK:
|
|
|
- return ISOCHRONOUS_A_F;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_IMPLICIT:
|
|
|
- return ISOCHRONOUS_A_I;
|
|
|
- }
|
|
|
- return ISOCHRONOUS_A_X;
|
|
|
- case LIBUSB_ISO_SYNC_TYPE_ADAPTIVE:
|
|
|
- switch(bmAttributes & LIBUSB_ISO_USAGE_TYPE_MASK) {
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_DATA:
|
|
|
- return ISOCHRONOUS_D_D;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_FEEDBACK:
|
|
|
- return ISOCHRONOUS_D_F;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_IMPLICIT:
|
|
|
- return ISOCHRONOUS_D_I;
|
|
|
- }
|
|
|
- return ISOCHRONOUS_D_X;
|
|
|
- case LIBUSB_ISO_SYNC_TYPE_SYNC:
|
|
|
- switch(bmAttributes & LIBUSB_ISO_USAGE_TYPE_MASK) {
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_DATA:
|
|
|
- return ISOCHRONOUS_S_D;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_FEEDBACK:
|
|
|
- return ISOCHRONOUS_S_F;
|
|
|
- case LIBUSB_ISO_USAGE_TYPE_IMPLICIT:
|
|
|
- return ISOCHRONOUS_S_I;
|
|
|
- }
|
|
|
- return ISOCHRONOUS_S_X;
|
|
|
- }
|
|
|
- return ISOCHRONOUS_X;
|
|
|
- }
|
|
|
-
|
|
|
- return UNKNOWN;
|
|
|
-}
|
|
|
-
|
|
|
-static void append(char **buf, char *append, size_t *off, size_t *len)
|
|
|
-{
|
|
|
- int new = strlen(append);
|
|
|
- if ((new + *off) >= *len)
|
|
|
- {
|
|
|
- *len *= 2;
|
|
|
- *buf = realloc(*buf, *len);
|
|
|
- }
|
|
|
-
|
|
|
- strcpy(*buf + *off, append);
|
|
|
- *off += new;
|
|
|
-}
|
|
|
-
|
|
|
-static bool setgetdes(ssize_t count, libusb_device *dev, struct libusb_device_handle *handle, struct libusb_config_descriptor **config, int cd, char **buf, size_t *off, size_t *len)
|
|
|
-{
|
|
|
- char tmp[512];
|
|
|
- int err;
|
|
|
-
|
|
|
- err = libusb_set_configuration(handle, cd);
|
|
|
- if (err) {
|
|
|
- sprintf(tmp, EOL " ** dev %d: Failed to set config descriptor to %d, err %d",
|
|
|
- (int)count, cd, err);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- err = libusb_get_active_config_descriptor(dev, config);
|
|
|
- if (err) {
|
|
|
- sprintf(tmp, EOL " ** dev %d: Failed to get active config descriptor set to %d, err %d",
|
|
|
- (int)count, cd, err);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- sprintf(tmp, EOL " ** dev %d: Set & Got active config descriptor to %d, err %d",
|
|
|
- (int)count, cd, err);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-static void usb_full(ssize_t count, libusb_device *dev, char **buf, size_t *off, size_t *len)
|
|
|
-{
|
|
|
- struct libusb_device_descriptor desc;
|
|
|
- struct libusb_device_handle *handle;
|
|
|
- struct libusb_config_descriptor *config;
|
|
|
- const struct libusb_interface_descriptor *idesc;
|
|
|
- const struct libusb_endpoint_descriptor *epdesc;
|
|
|
- unsigned char man[STRBUFLEN+1];
|
|
|
- unsigned char prod[STRBUFLEN+1];
|
|
|
- unsigned char ser[STRBUFLEN+1];
|
|
|
- char tmp[512];
|
|
|
- int err, i, j, k;
|
|
|
-
|
|
|
- err = libusb_get_device_descriptor(dev, &desc);
|
|
|
- if (err) {
|
|
|
- sprintf(tmp, EOL ".USB dev %d: Failed to get descriptor, err %d",
|
|
|
- (int)count, err);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- sprintf(tmp, EOL ".USB dev %d: Device Descriptor:" EOL "\tLength: %d" EOL
|
|
|
- "\tDescriptor Type: %s" EOL "\tUSB: %04x" EOL "\tDeviceClass: %d" EOL
|
|
|
- "\tDeviceSubClass: %d" EOL "\tDeviceProtocol: %d" EOL "\tMaxPacketSize0: %d" EOL
|
|
|
- "\tidVendor: %04x" EOL "\tidProduct: %04x" EOL "\tDeviceRelease: %x" EOL
|
|
|
- "\tNumConfigurations: %d",
|
|
|
- (int)count, (int)(desc.bLength), destype(desc.bDescriptorType),
|
|
|
- desc.bcdUSB, (int)(desc.bDeviceClass), (int)(desc.bDeviceSubClass),
|
|
|
- (int)(desc.bDeviceProtocol), (int)(desc.bMaxPacketSize0),
|
|
|
- desc.idVendor, desc.idProduct, desc.bcdDevice,
|
|
|
- (int)(desc.bNumConfigurations));
|
|
|
- append(buf, tmp, off, len);
|
|
|
-
|
|
|
- err = libusb_open(dev, &handle);
|
|
|
- if (err) {
|
|
|
- sprintf(tmp, EOL " ** dev %d: Failed to open, err %d", (int)count, err);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (libusb_kernel_driver_active(handle, 0) == 1) {
|
|
|
- sprintf(tmp, EOL " * dev %d: kernel attached", (int)count);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- }
|
|
|
-
|
|
|
- err = libusb_get_active_config_descriptor(dev, &config);
|
|
|
- if (err) {
|
|
|
- if (!setgetdes(count, dev, handle, &config, 1, buf, off, len)
|
|
|
- && !setgetdes(count, dev, handle, &config, 0, buf, off, len)) {
|
|
|
- libusb_close(handle);
|
|
|
- sprintf(tmp, EOL " ** dev %d: Failed to set config descriptor to %d or %d",
|
|
|
- (int)count, 1, 0);
|
|
|
- append(buf, tmp, off, len);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- sprintf(tmp, EOL " dev %d: Active Config:" EOL "\tDescriptorType: %s" EOL
|
|
|
- "\tNumInterfaces: %d" EOL "\tConfigurationValue: %d" EOL
|
|
|
- "\tAttributes: %d" EOL "\tMaxPower: %d",
|
|
|
- (int)count, destype(config->bDescriptorType),
|
|
|
- (int)(config->bNumInterfaces), (int)(config->iConfiguration),
|
|
|
- (int)(config->bmAttributes), (int)(config->MaxPower));
|
|
|
- append(buf, tmp, off, len);
|
|
|
-
|
|
|
- for (i = 0; i < (int)(config->bNumInterfaces); i++) {
|
|
|
- for (j = 0; j < config->interface[i].num_altsetting; j++) {
|
|
|
- idesc = &(config->interface[i].altsetting[j]);
|
|
|
-
|
|
|
- sprintf(tmp, EOL " _dev %d: Interface Descriptor %d:" EOL
|
|
|
- "\tDescriptorType: %s" EOL "\tInterfaceNumber: %d" EOL
|
|
|
- "\tNumEndpoints: %d" EOL "\tInterfaceClass: %d" EOL
|
|
|
- "\tInterfaceSubClass: %d" EOL "\tInterfaceProtocol: %d",
|
|
|
- (int)count, j, destype(idesc->bDescriptorType),
|
|
|
- (int)(idesc->bInterfaceNumber),
|
|
|
- (int)(idesc->bNumEndpoints),
|
|
|
- (int)(idesc->bInterfaceClass),
|
|
|
- (int)(idesc->bInterfaceSubClass),
|
|
|
- (int)(idesc->bInterfaceProtocol));
|
|
|
- append(buf, tmp, off, len);
|
|
|
-
|
|
|
- for (k = 0; k < (int)(idesc->bNumEndpoints); k++) {
|
|
|
- epdesc = &(idesc->endpoint[k]);
|
|
|
-
|
|
|
- sprintf(tmp, EOL " __dev %d: Interface %d Endpoint %d:" EOL
|
|
|
- "\tDescriptorType: %s" EOL
|
|
|
- "\tEndpointAddress: %s0x%x" EOL
|
|
|
- "\tAttributes: %s" EOL "\tMaxPacketSize: %d" EOL
|
|
|
- "\tInterval: %d" EOL "\tRefresh: %d",
|
|
|
- (int)count, (int)(idesc->bInterfaceNumber), k,
|
|
|
- destype(epdesc->bDescriptorType),
|
|
|
- epdir(epdesc->bEndpointAddress),
|
|
|
- (int)(epdesc->bEndpointAddress),
|
|
|
- epatt(epdesc->bmAttributes),
|
|
|
- epdesc->wMaxPacketSize,
|
|
|
- (int)(epdesc->bInterval),
|
|
|
- (int)(epdesc->bRefresh));
|
|
|
- append(buf, tmp, off, len);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- libusb_free_config_descriptor(config);
|
|
|
- config = NULL;
|
|
|
-
|
|
|
- err = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, man, STRBUFLEN);
|
|
|
- if (err < 0)
|
|
|
- sprintf((char *)man, "** err(%d)", err);
|
|
|
-
|
|
|
- err = libusb_get_string_descriptor_ascii(handle, desc.iProduct, prod, STRBUFLEN);
|
|
|
- if (err < 0)
|
|
|
- sprintf((char *)prod, "** err(%d)", err);
|
|
|
-
|
|
|
- err = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, ser, STRBUFLEN);
|
|
|
- if (err < 0)
|
|
|
- sprintf((char *)ser, "** err(%d)", err);
|
|
|
-
|
|
|
- sprintf(tmp, EOL " dev %d: More Info:" EOL "\tManufacturer: '%s'" EOL
|
|
|
- "\tProduct: '%s'" EOL "\tSerial '%s'",
|
|
|
- (int)count, man, prod, ser);
|
|
|
- append(buf, tmp, off, len);
|
|
|
-
|
|
|
- libusb_close(handle);
|
|
|
-}
|
|
|
-
|
|
|
-// Function to dump all USB devices
|
|
|
-static void usb_all()
|
|
|
-{
|
|
|
- libusb_device **list;
|
|
|
- ssize_t count, i;
|
|
|
- char *buf;
|
|
|
- size_t len, off;
|
|
|
-
|
|
|
- count = libusb_get_device_list(NULL, &list);
|
|
|
- if (count < 0) {
|
|
|
- applog(LOG_ERR, "USB all: failed, err %d", (int)count);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (count == 0)
|
|
|
- applog(LOG_WARNING, "USB all: found no devices");
|
|
|
- else
|
|
|
- {
|
|
|
- len = 10000;
|
|
|
- buf = malloc(len+1);
|
|
|
-
|
|
|
- sprintf(buf, "USB all: found %d devices", (int)count);
|
|
|
-
|
|
|
- off = strlen(buf);
|
|
|
-
|
|
|
- for (i = 0; i < count; i++)
|
|
|
- usb_full(i, list[i], &buf, &off, &len);
|
|
|
-
|
|
|
- applog(LOG_WARNING, "%s", buf);
|
|
|
-
|
|
|
- free(buf);
|
|
|
- }
|
|
|
-
|
|
|
- libusb_free_device_list(list, 1);
|
|
|
-}
|
|
|
-
|
|
|
-static void cgusb_check_init()
|
|
|
-{
|
|
|
- mutex_lock(&cgusb_lock);
|
|
|
-
|
|
|
- if (list_lock == NULL) {
|
|
|
- list_lock = calloc(1, sizeof(*list_lock));
|
|
|
- mutex_init(list_lock);
|
|
|
-
|
|
|
- if (opt_usbdump >= 0) {
|
|
|
- libusb_set_debug(NULL, opt_usbdump);
|
|
|
- usb_all();
|
|
|
- }
|
|
|
-
|
|
|
- usb_commands = malloc(sizeof(*usb_commands) * C_MAX);
|
|
|
-
|
|
|
- // use constants so the stat generation is very quick
|
|
|
- // and the association between number and name can't
|
|
|
- // be missalined easily
|
|
|
- usb_commands[C_PING] = C_PING_S;
|
|
|
- usb_commands[C_CLEAR] = C_CLEAR_S;
|
|
|
- usb_commands[C_REQUESTVERSION] = C_REQUESTVERSION_S;
|
|
|
- usb_commands[C_GETVERSION] = C_GETVERSION_S;
|
|
|
- usb_commands[C_REQUESTFPGACOUNT] = C_REQUESTFPGACOUNT_S;
|
|
|
- usb_commands[C_GETFPGACOUNT] = C_GETFPGACOUNT_S;
|
|
|
- usb_commands[C_STARTPROGRAM] = C_STARTPROGRAM_S;
|
|
|
- usb_commands[C_STARTPROGRAMSTATUS] = C_STARTPROGRAMSTATUS_S;
|
|
|
- usb_commands[C_PROGRAM] = C_PROGRAM_S;
|
|
|
- usb_commands[C_PROGRAMSTATUS] = C_PROGRAMSTATUS_S;
|
|
|
- usb_commands[C_PROGRAMSTATUS2] = C_PROGRAMSTATUS2_S;
|
|
|
- usb_commands[C_FINALPROGRAMSTATUS] = C_FINALPROGRAMSTATUS_S;
|
|
|
- usb_commands[C_SETCLOCK] = C_SETCLOCK_S;
|
|
|
- usb_commands[C_REPLYSETCLOCK] = C_REPLYSETCLOCK_S;
|
|
|
- usb_commands[C_REQUESTUSERCODE] = C_REQUESTUSERCODE_S;
|
|
|
- usb_commands[C_GETUSERCODE] = C_GETUSERCODE_S;
|
|
|
- usb_commands[C_REQUESTTEMPERATURE] = C_REQUESTTEMPERATURE_S;
|
|
|
- usb_commands[C_GETTEMPERATURE] = C_GETTEMPERATURE_S;
|
|
|
- usb_commands[C_SENDWORK] = C_SENDWORK_S;
|
|
|
- usb_commands[C_SENDWORKSTATUS] = C_SENDWORKSTATUS_S;
|
|
|
- usb_commands[C_REQUESTWORKSTATUS] = C_REQUESTWORKSTATUS_S;
|
|
|
- usb_commands[C_GETWORKSTATUS] = C_GETWORKSTATUS_S;
|
|
|
- }
|
|
|
-
|
|
|
- mutex_unlock(&cgusb_lock);
|
|
|
-}
|
|
|
-
|
|
|
-static bool in_use(libusb_device *dev, bool lock)
|
|
|
-{
|
|
|
- struct usb_list *usb_tmp;
|
|
|
- bool used = false;
|
|
|
- uint8_t bus_number;
|
|
|
- uint8_t device_address;
|
|
|
-
|
|
|
- bus_number = libusb_get_bus_number(dev);
|
|
|
- device_address = libusb_get_device_address(dev);
|
|
|
-
|
|
|
- if (lock)
|
|
|
- mutex_lock(list_lock);
|
|
|
-
|
|
|
- if ((usb_tmp = usb_head))
|
|
|
- do {
|
|
|
- if (bus_number == usb_tmp->bus_number
|
|
|
- && device_address == usb_tmp->device_address) {
|
|
|
- used = true;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- usb_tmp = usb_tmp->next;
|
|
|
-
|
|
|
- } while (usb_tmp != usb_head);
|
|
|
-
|
|
|
- if (lock)
|
|
|
- mutex_unlock(list_lock);
|
|
|
-
|
|
|
- return used;
|
|
|
-}
|
|
|
-
|
|
|
-static void add_used(libusb_device *dev, bool lock)
|
|
|
-{
|
|
|
- struct usb_list *usb_tmp;
|
|
|
- char buf[128];
|
|
|
- uint8_t bus_number;
|
|
|
- uint8_t device_address;
|
|
|
-
|
|
|
- bus_number = libusb_get_bus_number(dev);
|
|
|
- device_address = libusb_get_device_address(dev);
|
|
|
-
|
|
|
- if (lock)
|
|
|
- mutex_lock(list_lock);
|
|
|
-
|
|
|
- if (in_use(dev, false)) {
|
|
|
- if (lock)
|
|
|
- mutex_unlock(list_lock);
|
|
|
-
|
|
|
- sprintf(buf, "add_used() duplicate bus_number %d device_address %d",
|
|
|
- bus_number, device_address);
|
|
|
- quit(1, buf);
|
|
|
- }
|
|
|
-
|
|
|
- usb_tmp = malloc(sizeof(*usb_tmp));
|
|
|
-
|
|
|
- usb_tmp->bus_number = bus_number;
|
|
|
- usb_tmp->device_address = device_address;
|
|
|
-
|
|
|
- if (usb_head) {
|
|
|
- // add to end
|
|
|
- usb_tmp->prev = usb_head->prev;
|
|
|
- usb_tmp->next = usb_head;
|
|
|
- usb_head->prev = usb_tmp;
|
|
|
- usb_tmp->prev->next = usb_tmp;
|
|
|
- } else {
|
|
|
- usb_tmp->prev = usb_tmp;
|
|
|
- usb_tmp->next = usb_tmp;
|
|
|
- usb_head = usb_tmp;
|
|
|
- }
|
|
|
-
|
|
|
- if (lock)
|
|
|
- mutex_unlock(list_lock);
|
|
|
-}
|
|
|
-
|
|
|
-static void release(uint8_t bus_number, uint8_t device_address, bool lock)
|
|
|
-{
|
|
|
- struct usb_list *usb_tmp;
|
|
|
- bool found = false;
|
|
|
- char buf[128];
|
|
|
-
|
|
|
- if (lock)
|
|
|
- mutex_lock(list_lock);
|
|
|
-
|
|
|
- usb_tmp = usb_head;
|
|
|
- if (usb_tmp)
|
|
|
- do {
|
|
|
- if (bus_number == usb_tmp->bus_number
|
|
|
- && device_address == usb_tmp->device_address) {
|
|
|
- found = true;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- usb_tmp = usb_tmp->next;
|
|
|
-
|
|
|
- } while (usb_tmp != usb_head);
|
|
|
-
|
|
|
- if (!found) {
|
|
|
- if (lock)
|
|
|
- mutex_unlock(list_lock);
|
|
|
-
|
|
|
- sprintf(buf, "release() unknown: bus_number %d device_address %d",
|
|
|
- bus_number, device_address);
|
|
|
- quit(1, buf);
|
|
|
- }
|
|
|
-
|
|
|
- if (usb_tmp->next == usb_tmp) {
|
|
|
- usb_head = NULL;
|
|
|
- } else {
|
|
|
- usb_tmp->next->prev = usb_tmp->prev;
|
|
|
- usb_tmp->prev->next = usb_tmp->next;
|
|
|
- }
|
|
|
-
|
|
|
- if (lock)
|
|
|
- mutex_unlock(list_lock);
|
|
|
-
|
|
|
- free(usb_tmp);
|
|
|
-}
|
|
|
-
|
|
|
-static void release_dev(libusb_device *dev, bool lock)
|
|
|
-{
|
|
|
- uint8_t bus_number;
|
|
|
- uint8_t device_address;
|
|
|
-
|
|
|
- bus_number = libusb_get_bus_number(dev);
|
|
|
- device_address = libusb_get_device_address(dev);
|
|
|
-
|
|
|
- release(bus_number, device_address, lock);
|
|
|
-}
|
|
|
-
|
|
|
-#if 0
|
|
|
-static void release_cgusb(struct cg_usb_device *cgusb, bool lock)
|
|
|
-{
|
|
|
- release(cgusb->bus_number, cgusb->device_address, lock);
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-static struct cg_usb_device *free_cgusb(struct cg_usb_device *cgusb)
|
|
|
-{
|
|
|
- if (cgusb->serial_string && cgusb->serial_string != BLANK)
|
|
|
- free(cgusb->serial_string);
|
|
|
-
|
|
|
- if (cgusb->manuf_string && cgusb->manuf_string != BLANK)
|
|
|
- free(cgusb->manuf_string);
|
|
|
-
|
|
|
- if (cgusb->prod_string && cgusb->prod_string != BLANK)
|
|
|
- free(cgusb->prod_string);
|
|
|
-
|
|
|
- free(cgusb->descriptor);
|
|
|
-
|
|
|
- free(cgusb);
|
|
|
-
|
|
|
- return NULL;
|
|
|
-}
|
|
|
-
|
|
|
-void usb_uninit(struct cgpu_info *cgpu)
|
|
|
-{
|
|
|
- libusb_release_interface(cgpu->usbdev->handle, cgpu->usbdev->found->interface);
|
|
|
- libusb_close(cgpu->usbdev->handle);
|
|
|
- cgpu->usbdev = free_cgusb(cgpu->usbdev);
|
|
|
-}
|
|
|
-
|
|
|
-bool usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct usb_find_devices *found)
|
|
|
-{
|
|
|
- struct cg_usb_device *cgusb = NULL;
|
|
|
- struct libusb_config_descriptor *config = NULL;
|
|
|
- const struct libusb_interface_descriptor *idesc;
|
|
|
- const struct libusb_endpoint_descriptor *epdesc;
|
|
|
- unsigned char strbuf[STRBUFLEN+1];
|
|
|
- int err, i, j, k;
|
|
|
-
|
|
|
- cgusb = calloc(1, sizeof(*cgusb));
|
|
|
- cgusb->found = found;
|
|
|
-
|
|
|
- cgusb->bus_number = libusb_get_bus_number(dev);
|
|
|
- cgusb->device_address = libusb_get_device_address(dev);
|
|
|
-
|
|
|
- cgusb->descriptor = calloc(1, sizeof(*(cgusb->descriptor)));
|
|
|
-
|
|
|
- err = libusb_get_device_descriptor(dev, cgusb->descriptor);
|
|
|
- if (err) {
|
|
|
- applog(LOG_ERR, "USB init failed to get descriptor, err %d", err);
|
|
|
- goto dame;
|
|
|
- }
|
|
|
-
|
|
|
- err = libusb_open(dev, &(cgusb->handle));
|
|
|
- if (err) {
|
|
|
- switch (err) {
|
|
|
- case LIBUSB_ERROR_ACCESS:
|
|
|
- applog(LOG_ERR, "USB init open device failed, err %d, you dont have priviledge to access the device", err);
|
|
|
- break;
|
|
|
-#ifdef WIN32
|
|
|
- // Windows specific message
|
|
|
- case LIBUSB_ERROR_NOT_SUPPORTED:
|
|
|
- applog(LOG_ERR, "USB init, open device failed, err %d, you need to install a Windows USB driver for the device", err);
|
|
|
- break;
|
|
|
-#endif
|
|
|
- default:
|
|
|
- applog(LOG_ERR, "USB init, open device failed, err %d", err);
|
|
|
- }
|
|
|
- goto dame;
|
|
|
- }
|
|
|
-
|
|
|
- if (libusb_kernel_driver_active(cgusb->handle, 0) == 1) {
|
|
|
- applog(LOG_WARNING, "USB init, kernel attached ...");
|
|
|
- if (libusb_detach_kernel_driver(cgusb->handle, 0) == 0)
|
|
|
- applog(LOG_WARNING, "USB init, kernel detached successfully");
|
|
|
- else
|
|
|
- applog(LOG_WARNING, "USB init, kernel detach failed :(");
|
|
|
- }
|
|
|
-
|
|
|
- err = libusb_set_configuration(cgusb->handle, found->config);
|
|
|
- if (err) {
|
|
|
- switch(err) {
|
|
|
- case LIBUSB_ERROR_BUSY:
|
|
|
- applog(LOG_WARNING, "USB init, %s device %d:%d in use",
|
|
|
- found->name, cgusb->bus_number, cgusb->device_address);
|
|
|
- break;
|
|
|
- default:
|
|
|
- applog(LOG_DEBUG, "USB init, failed to set config to %d, err %d",
|
|
|
- found->config, err);
|
|
|
- }
|
|
|
- goto cldame;
|
|
|
- }
|
|
|
-
|
|
|
- err = libusb_get_active_config_descriptor(dev, &config);
|
|
|
- if (err) {
|
|
|
- applog(LOG_DEBUG, "USB init, failed to get config descriptor %d, err %d",
|
|
|
- found->config, err);
|
|
|
- goto cldame;
|
|
|
- }
|
|
|
-
|
|
|
- if ((int)(config->bNumInterfaces) < found->interface)
|
|
|
- goto cldame;
|
|
|
-
|
|
|
- for (i = 0; i < found->epcount; i++)
|
|
|
- found->eps[i].found = false;
|
|
|
-
|
|
|
- for (i = 0; i < config->interface[found->interface].num_altsetting; i++) {
|
|
|
- idesc = &(config->interface[found->interface].altsetting[i]);
|
|
|
- for (j = 0; j < (int)(idesc->bNumEndpoints); j++) {
|
|
|
- epdesc = &(idesc->endpoint[j]);
|
|
|
- for (k = 0; k < found->epcount; k++) {
|
|
|
- if (!found->eps[k].found) {
|
|
|
- if (epdesc->bmAttributes == found->eps[k].att
|
|
|
- && epdesc->wMaxPacketSize >= found->eps[k].size
|
|
|
- && epdesc->bEndpointAddress == found->eps[k].ep) {
|
|
|
- found->eps[k].found = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for (i = 0; i < found->epcount; i++)
|
|
|
- if (found->eps[i].found == false)
|
|
|
- goto cldame;
|
|
|
-
|
|
|
- err = libusb_claim_interface(cgusb->handle, found->interface);
|
|
|
- if (err) {
|
|
|
- applog(LOG_DEBUG, "USB init, claim interface %d failed, err %d",
|
|
|
- found->interface, err);
|
|
|
- goto cldame;
|
|
|
- }
|
|
|
-
|
|
|
- cgusb->usbver = cgusb->descriptor->bcdUSB;
|
|
|
-
|
|
|
-// TODO: allow this with the right version of the libusb include and running library
|
|
|
-// cgusb->speed = libusb_get_device_speed(dev);
|
|
|
-
|
|
|
- err = libusb_get_string_descriptor_ascii(cgusb->handle,
|
|
|
- cgusb->descriptor->iProduct, strbuf, STRBUFLEN);
|
|
|
- if (err > 0)
|
|
|
- cgusb->prod_string = strdup((char *)strbuf);
|
|
|
- else
|
|
|
- cgusb->prod_string = (char *)BLANK;
|
|
|
-
|
|
|
- err = libusb_get_string_descriptor_ascii(cgusb->handle,
|
|
|
- cgusb->descriptor->iManufacturer, strbuf, STRBUFLEN);
|
|
|
- if (err > 0)
|
|
|
- cgusb->manuf_string = strdup((char *)strbuf);
|
|
|
- else
|
|
|
- cgusb->manuf_string = (char *)BLANK;
|
|
|
-
|
|
|
- err = libusb_get_string_descriptor_ascii(cgusb->handle,
|
|
|
- cgusb->descriptor->iSerialNumber, strbuf, STRBUFLEN);
|
|
|
- if (err > 0)
|
|
|
- cgusb->serial_string = strdup((char *)strbuf);
|
|
|
- else
|
|
|
- cgusb->serial_string = (char *)BLANK;
|
|
|
-
|
|
|
-// TODO: ?
|
|
|
-// cgusb->fwVersion <- for temp1/temp2 decision? or serial? (driver-modminer.c)
|
|
|
-// cgusb->interfaceVersion
|
|
|
-
|
|
|
- applog(LOG_DEBUG, "USB init device bus_number=%d device_address=%d usbver=%04x prod='%s' manuf='%s' serial='%s'", (int)(cgusb->bus_number), (int)(cgusb->device_address), cgusb->usbver, cgusb->prod_string, cgusb->manuf_string, cgusb->serial_string);
|
|
|
-
|
|
|
- cgpu->usbdev = cgusb;
|
|
|
-
|
|
|
- libusb_free_config_descriptor(config);
|
|
|
-
|
|
|
- return true;
|
|
|
-
|
|
|
-cldame:
|
|
|
-
|
|
|
- libusb_close(cgusb->handle);
|
|
|
-
|
|
|
-dame:
|
|
|
-
|
|
|
- if (config)
|
|
|
- libusb_free_config_descriptor(config);
|
|
|
-
|
|
|
- cgusb = free_cgusb(cgusb);
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-static bool usb_check_device(struct device_api *api, struct libusb_device *dev, struct usb_find_devices *look)
|
|
|
-{
|
|
|
- struct libusb_device_descriptor desc;
|
|
|
- int err;
|
|
|
-
|
|
|
- err = libusb_get_device_descriptor(dev, &desc);
|
|
|
- if (err) {
|
|
|
- applog(LOG_DEBUG, "USB check device: Failed to get descriptor, err %d", err);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if (desc.idVendor != look->idVendor || desc.idProduct != look->idProduct) {
|
|
|
- applog(LOG_DEBUG, "%s looking for %04x:%04x but found %04x:%04x instead",
|
|
|
- api->name, look->idVendor, look->idProduct, desc.idVendor, desc.idProduct);
|
|
|
-
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- applog(LOG_DEBUG, "%s looking for and found %04x:%04x",
|
|
|
- api->name, look->idVendor, look->idProduct);
|
|
|
-
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-static struct usb_find_devices *usb_check_each(int drv, struct device_api *api, struct libusb_device *dev)
|
|
|
-{
|
|
|
- struct usb_find_devices *found;
|
|
|
- int i;
|
|
|
-
|
|
|
- for (i = 0; find_dev[i].drv != DRV_LAST; i++)
|
|
|
- if (find_dev[i].drv == drv) {
|
|
|
- if (usb_check_device(api, dev, &(find_dev[i]))) {
|
|
|
- found = malloc(sizeof(*found));
|
|
|
- memcpy(found, &(find_dev[i]), sizeof(*found));
|
|
|
- return found;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return NULL;
|
|
|
-}
|
|
|
-
|
|
|
-static struct usb_find_devices *usb_check(__maybe_unused struct device_api *api, __maybe_unused struct libusb_device *dev)
|
|
|
-{
|
|
|
-#ifdef USE_BITFORCE
|
|
|
- if (api == &bitforce_api)
|
|
|
- return usb_check_each(DRV_BITFORCE, api, dev);
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_ICARUS
|
|
|
- if (api == &icarus_api)
|
|
|
- return usb_check_each(DRV_ICARUS, api, dev);
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef USE_MODMINER
|
|
|
- if (api == &modminer_api)
|
|
|
- return usb_check_each(DRV_MODMINER, api, dev);
|
|
|
-#endif
|
|
|
-
|
|
|
- return NULL;
|
|
|
-}
|
|
|
-
|
|
|
-void usb_detect(struct device_api *api, bool (*device_detect)(struct libusb_device *, struct usb_find_devices *))
|
|
|
-{
|
|
|
- libusb_device **list;
|
|
|
- ssize_t count, i;
|
|
|
- struct usb_find_devices *found;
|
|
|
-
|
|
|
- cgusb_check_init();
|
|
|
-
|
|
|
- count = libusb_get_device_list(NULL, &list);
|
|
|
- if (count < 0) {
|
|
|
- applog(LOG_DEBUG, "USB scan devices: failed, err %d", count);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (count == 0)
|
|
|
- applog(LOG_DEBUG, "USB scan devices: found no devices");
|
|
|
-
|
|
|
- for (i = 0; i < count; i++) {
|
|
|
- mutex_lock(list_lock);
|
|
|
-
|
|
|
- if (in_use(list[i], false))
|
|
|
- mutex_unlock(list_lock);
|
|
|
- else {
|
|
|
- add_used(list[i], false);
|
|
|
-
|
|
|
- mutex_unlock(list_lock);
|
|
|
-
|
|
|
- found = usb_check(api, list[i]);
|
|
|
- if (!found)
|
|
|
- release_dev(list[i], true);
|
|
|
- else
|
|
|
- if (!device_detect(list[i], found))
|
|
|
- release_dev(list[i], true);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- libusb_free_device_list(list, 1);
|
|
|
-}
|
|
|
-
|
|
|
-// Set this to 0 to remove stats processing
|
|
|
-#define DO_USB_STATS 1
|
|
|
-
|
|
|
-#if DO_USB_STATS
|
|
|
-#define USB_STATS(sgpu, sta, fin, err, cmd, seq) stats(cgpu, sta, fin, err, cmd, seq)
|
|
|
-#define STATS_TIMEVAL(tv) gettimeofday(tv, NULL)
|
|
|
-#else
|
|
|
-#define USB_STATS(sgpu, sta, fin, err, cmd, seq)
|
|
|
-#define STATS_TIMEVAL(tv)
|
|
|
-#endif
|
|
|
-
|
|
|
-// The stat data can be spurious due to not locking it before copying it -
|
|
|
-// however that would require the stat() function to also lock and release
|
|
|
-// a mutex every time a usb read or write is called which would slow
|
|
|
-// things down more
|
|
|
-struct api_data *api_usb_stats(__maybe_unused int *count)
|
|
|
-{
|
|
|
-#if DO_USB_STATS
|
|
|
- struct cg_usb_stats_details *details;
|
|
|
- struct cg_usb_stats *sta;
|
|
|
- struct api_data *root = NULL;
|
|
|
- int device;
|
|
|
- int cmdseq;
|
|
|
-
|
|
|
- cgusb_check_init();
|
|
|
-
|
|
|
- if (next_stat == 0)
|
|
|
- return NULL;
|
|
|
-
|
|
|
- while (*count < next_stat * C_MAX * 2) {
|
|
|
- device = *count / (C_MAX * 2);
|
|
|
- cmdseq = *count % (C_MAX * 2);
|
|
|
-
|
|
|
- (*count)++;
|
|
|
-
|
|
|
- sta = &(usb_stats[device]);
|
|
|
- details = &(sta->details[cmdseq]);
|
|
|
-
|
|
|
- // Only show stats that have results
|
|
|
- if (details->item[CMD_CMD].count == 0 &&
|
|
|
- details->item[CMD_TIMEOUT].count == 0 &&
|
|
|
- details->item[CMD_ERROR].count == 0)
|
|
|
- continue;
|
|
|
-
|
|
|
- root = api_add_string(root, "Name", sta->name, false);
|
|
|
- root = api_add_int(root, "ID", &(sta->device_id), false);
|
|
|
- root = api_add_const(root, "Stat", usb_commands[cmdseq/2], false);
|
|
|
- root = api_add_int(root, "Seq", &(details->seq), true);
|
|
|
- root = api_add_uint64(root, "Count",
|
|
|
- &(details->item[CMD_CMD].count), true);
|
|
|
- root = api_add_double(root, "Total Delay",
|
|
|
- &(details->item[CMD_CMD].total_delay), true);
|
|
|
- root = api_add_double(root, "Min Delay",
|
|
|
- &(details->item[CMD_CMD].min_delay), true);
|
|
|
- root = api_add_double(root, "Max Delay",
|
|
|
- &(details->item[CMD_CMD].max_delay), true);
|
|
|
- root = api_add_uint64(root, "Timeout Count",
|
|
|
- &(details->item[CMD_TIMEOUT].count), true);
|
|
|
- root = api_add_double(root, "Timeout Total Delay",
|
|
|
- &(details->item[CMD_TIMEOUT].total_delay), true);
|
|
|
- root = api_add_double(root, "Timeout Min Delay",
|
|
|
- &(details->item[CMD_TIMEOUT].min_delay), true);
|
|
|
- root = api_add_double(root, "Timeout Max Delay",
|
|
|
- &(details->item[CMD_TIMEOUT].max_delay), true);
|
|
|
- root = api_add_uint64(root, "Error Count",
|
|
|
- &(details->item[CMD_ERROR].count), true);
|
|
|
- root = api_add_double(root, "Error Total Delay",
|
|
|
- &(details->item[CMD_ERROR].total_delay), true);
|
|
|
- root = api_add_double(root, "Error Min Delay",
|
|
|
- &(details->item[CMD_ERROR].min_delay), true);
|
|
|
- root = api_add_double(root, "Error Max Delay",
|
|
|
- &(details->item[CMD_ERROR].max_delay), true);
|
|
|
- root = api_add_timeval(root, "First Command",
|
|
|
- &(details->item[CMD_CMD].first), true);
|
|
|
- root = api_add_timeval(root, "Last Command",
|
|
|
- &(details->item[CMD_CMD].last), true);
|
|
|
- root = api_add_timeval(root, "First Timeout",
|
|
|
- &(details->item[CMD_TIMEOUT].first), true);
|
|
|
- root = api_add_timeval(root, "Last Timeout",
|
|
|
- &(details->item[CMD_TIMEOUT].last), true);
|
|
|
- root = api_add_timeval(root, "First Error",
|
|
|
- &(details->item[CMD_ERROR].first), true);
|
|
|
- root = api_add_timeval(root, "Last Error",
|
|
|
- &(details->item[CMD_ERROR].last), true);
|
|
|
-
|
|
|
- return root;
|
|
|
- }
|
|
|
-#endif
|
|
|
- return NULL;
|
|
|
-}
|
|
|
-
|
|
|
-#if DO_USB_STATS
|
|
|
-static void newstats(struct cgpu_info *cgpu)
|
|
|
-{
|
|
|
- int i;
|
|
|
-
|
|
|
- cgpu->usbstat = ++next_stat;
|
|
|
-
|
|
|
- usb_stats = realloc(usb_stats, sizeof(*usb_stats) * next_stat);
|
|
|
- usb_stats[next_stat-1].name = cgpu->api->name;
|
|
|
- usb_stats[next_stat-1].device_id = -1;
|
|
|
- usb_stats[next_stat-1].details = calloc(1, sizeof(struct cg_usb_stats_details) * C_MAX * 2);
|
|
|
- for (i = 1; i < C_MAX * 2; i += 2)
|
|
|
- usb_stats[next_stat-1].details[i].seq = 1;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-void update_usb_stats(__maybe_unused struct cgpu_info *cgpu)
|
|
|
-{
|
|
|
-#if DO_USB_STATS
|
|
|
- if (cgpu->usbstat < 1)
|
|
|
- newstats(cgpu);
|
|
|
-
|
|
|
- // we don't know the device_id until after add_cgpu()
|
|
|
- usb_stats[cgpu->usbstat - 1].device_id = cgpu->device_id;
|
|
|
-#endif
|
|
|
-}
|
|
|
-
|
|
|
-#if DO_USB_STATS
|
|
|
-static void stats(struct cgpu_info *cgpu, struct timeval *tv_start, struct timeval *tv_finish, int err, enum usb_cmds cmd, int seq)
|
|
|
-{
|
|
|
- struct cg_usb_stats_details *details;
|
|
|
- double diff;
|
|
|
- int item;
|
|
|
-
|
|
|
- if (cgpu->usbstat < 1)
|
|
|
- newstats(cgpu);
|
|
|
-
|
|
|
- details = &(usb_stats[cgpu->usbstat - 1].details[cmd * 2 + seq]);
|
|
|
-
|
|
|
- diff = tdiff(tv_finish, tv_start);
|
|
|
-
|
|
|
- switch (err) {
|
|
|
- case LIBUSB_SUCCESS:
|
|
|
- item = CMD_CMD;
|
|
|
- break;
|
|
|
- case LIBUSB_ERROR_TIMEOUT:
|
|
|
- item = CMD_TIMEOUT;
|
|
|
- break;
|
|
|
- default:
|
|
|
- item = CMD_ERROR;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if (details->item[item].count == 0) {
|
|
|
- details->item[item].min_delay = diff;
|
|
|
- memcpy(&(details->item[item].first), tv_start, sizeof(*tv_start));
|
|
|
- } else if (diff < details->item[item].min_delay)
|
|
|
- details->item[item].min_delay = diff;
|
|
|
-
|
|
|
- if (diff > details->item[item].max_delay)
|
|
|
- details->item[item].max_delay = diff;
|
|
|
-
|
|
|
- details->item[item].total_delay += diff;
|
|
|
- memcpy(&(details->item[item].last), tv_start, sizeof(tv_start));
|
|
|
- details->item[item].count++;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *processed, unsigned int timeout, int eol, enum usb_cmds cmd)
|
|
|
-{
|
|
|
- struct cg_usb_device *usbdev = cgpu->usbdev;
|
|
|
-#if DO_USB_STATS
|
|
|
- struct timeval tv_start, tv_finish;
|
|
|
-#endif
|
|
|
- int err, got, tot;
|
|
|
- bool first = true;
|
|
|
-
|
|
|
- if (eol == -1) {
|
|
|
- got = 0;
|
|
|
- STATS_TIMEVAL(&tv_start);
|
|
|
- err = libusb_bulk_transfer(usbdev->handle,
|
|
|
- usbdev->found->eps[ep].ep,
|
|
|
- (unsigned char *)buf,
|
|
|
- bufsiz, &got,
|
|
|
- timeout == DEVTIMEOUT ? usbdev->found->timeout : timeout);
|
|
|
- STATS_TIMEVAL(&tv_finish);
|
|
|
- USB_STATS(cgpu, &tv_start, &tv_finish, err, cmd, SEQ0);
|
|
|
-
|
|
|
- *processed = got;
|
|
|
-
|
|
|
- return err;
|
|
|
- }
|
|
|
-
|
|
|
- tot = 0;
|
|
|
- err = LIBUSB_SUCCESS;
|
|
|
- while (bufsiz) {
|
|
|
- got = 0;
|
|
|
- STATS_TIMEVAL(&tv_start);
|
|
|
- err = libusb_bulk_transfer(usbdev->handle,
|
|
|
- usbdev->found->eps[ep].ep,
|
|
|
- (unsigned char *)buf,
|
|
|
- 1, &got,
|
|
|
- timeout == DEVTIMEOUT ? usbdev->found->timeout : timeout);
|
|
|
- STATS_TIMEVAL(&tv_finish);
|
|
|
- USB_STATS(cgpu, &tv_start, &tv_finish, err, cmd, first ? SEQ0 : SEQ1);
|
|
|
-
|
|
|
- tot += got;
|
|
|
-
|
|
|
- if (err)
|
|
|
- break;
|
|
|
-
|
|
|
- if (eol == buf[0])
|
|
|
- break;
|
|
|
-
|
|
|
- buf += got;
|
|
|
- bufsiz -= got;
|
|
|
-
|
|
|
- first = false;
|
|
|
- }
|
|
|
-
|
|
|
- *processed = tot;
|
|
|
-
|
|
|
- return err;
|
|
|
-}
|
|
|
-
|
|
|
-int _usb_write(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *processed, unsigned int timeout, enum usb_cmds cmd)
|
|
|
-{
|
|
|
- struct cg_usb_device *usbdev = cgpu->usbdev;
|
|
|
-#if DO_USB_STATS
|
|
|
- struct timeval tv_start, tv_finish;
|
|
|
-#endif
|
|
|
- int err, sent;
|
|
|
-
|
|
|
- sent = 0;
|
|
|
- STATS_TIMEVAL(&tv_start);
|
|
|
- err = libusb_bulk_transfer(usbdev->handle,
|
|
|
- usbdev->found->eps[ep].ep,
|
|
|
- (unsigned char *)buf,
|
|
|
- bufsiz, &sent,
|
|
|
- timeout == DEVTIMEOUT ? usbdev->found->timeout : timeout);
|
|
|
- STATS_TIMEVAL(&tv_finish);
|
|
|
- USB_STATS(cgpu, &tv_start, &tv_finish, err, cmd, SEQ0);
|
|
|
-
|
|
|
- *processed = sent;
|
|
|
-
|
|
|
- return err;
|
|
|
-}
|
|
|
-
|
|
|
-void usb_cleanup()
|
|
|
-{
|
|
|
- // TODO:
|
|
|
-}
|
Luke Dashjr