Browse Source

Merge pull request #492 from kanoi/master

usbutils handle multiple interfaces
nfactor-troky
kanoi 11 years ago
parent
commit
9ccb3a8f11
  1. 2
      driver-avalon.c
  2. 17
      driver-bflsc.c
  3. 17
      driver-bitforce.c
  4. 76
      driver-icarus.c
  5. 566
      usbutils.c
  6. 20
      usbutils.h

2
driver-avalon.c

@ -531,7 +531,7 @@ static void avalon_initialise(struct cgpu_info *avalon) @@ -531,7 +531,7 @@ static void avalon_initialise(struct cgpu_info *avalon)
if (avalon->usbinfo.nodev)
return;
interface = avalon->usbdev->found->interface;
interface = usb_interface(avalon);
// Reset
err = usb_transfer(avalon, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_RESET, interface, C_RESET);

17
driver-bflsc.c

@ -452,7 +452,7 @@ static bool bflsc_qres(struct cgpu_info *bflsc, char *buf, size_t bufsiz, int de @@ -452,7 +452,7 @@ static bool bflsc_qres(struct cgpu_info *bflsc, char *buf, size_t bufsiz, int de
static void __bflsc_initialise(struct cgpu_info *bflsc)
{
int err;
int err, interface;
// TODO: does x-link bypass the other device FTDI? (I think it does)
// So no initialisation required except for the master device?
@ -460,9 +460,10 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -460,9 +460,10 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
if (bflsc->usbinfo.nodev)
return;
interface = usb_interface(bflsc);
// Reset
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_RESET, bflsc->usbdev->found->interface, C_RESET);
FTDI_VALUE_RESET, interface, C_RESET);
applog(LOG_DEBUG, "%s%i: reset got err %d",
bflsc->drv->name, bflsc->device_id, err);
@ -477,7 +478,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -477,7 +478,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
// Set data control
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
FTDI_VALUE_DATA_BAS, bflsc->usbdev->found->interface, C_SETDATA);
FTDI_VALUE_DATA_BAS, interface, C_SETDATA);
applog(LOG_DEBUG, "%s%i: setdata got err %d",
bflsc->drv->name, bflsc->device_id, err);
@ -487,7 +488,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -487,7 +488,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
// Set the baud
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD_BAS,
(FTDI_INDEX_BAUD_BAS & 0xff00) | bflsc->usbdev->found->interface,
(FTDI_INDEX_BAUD_BAS & 0xff00) | interface,
C_SETBAUD);
applog(LOG_DEBUG, "%s%i: setbaud got err %d",
@ -498,7 +499,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -498,7 +499,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
// Set Flow Control
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, bflsc->usbdev->found->interface, C_SETFLOW);
FTDI_VALUE_FLOW, interface, C_SETFLOW);
applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
bflsc->drv->name, bflsc->device_id, err);
@ -508,7 +509,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -508,7 +509,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
// Set Modem Control
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, bflsc->usbdev->found->interface, C_SETMODEM);
FTDI_VALUE_MODEM, interface, C_SETMODEM);
applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
bflsc->drv->name, bflsc->device_id, err);
@ -518,7 +519,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -518,7 +519,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
// Clear any sent data
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_PURGE_TX, bflsc->usbdev->found->interface, C_PURGETX);
FTDI_VALUE_PURGE_TX, interface, C_PURGETX);
applog(LOG_DEBUG, "%s%i: purgetx got err %d",
bflsc->drv->name, bflsc->device_id, err);
@ -528,7 +529,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc) @@ -528,7 +529,7 @@ static void __bflsc_initialise(struct cgpu_info *bflsc)
// Clear any received data
err = usb_transfer(bflsc, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_PURGE_RX, bflsc->usbdev->found->interface, C_PURGERX);
FTDI_VALUE_PURGE_RX, interface, C_PURGERX);
applog(LOG_DEBUG, "%s%i: purgerx got err %d",
bflsc->drv->name, bflsc->device_id, err);

17
driver-bitforce.c

@ -81,7 +81,7 @@ struct device_drv bitforce_drv; @@ -81,7 +81,7 @@ struct device_drv bitforce_drv;
static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
{
int err;
int err, interface;
if (lock)
mutex_lock(&bitforce->device_mutex);
@ -89,9 +89,10 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -89,9 +89,10 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
if (bitforce->usbinfo.nodev)
goto failed;
interface = usb_interface(bitforce);
// Reset
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_RESET, bitforce->usbdev->found->interface, C_RESET);
FTDI_VALUE_RESET, interface, C_RESET);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: reset got err %d",
bitforce->drv->name, bitforce->device_id, err);
@ -101,7 +102,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -101,7 +102,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
// Set data control
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
FTDI_VALUE_DATA_BFL, bitforce->usbdev->found->interface, C_SETDATA);
FTDI_VALUE_DATA_BFL, interface, C_SETDATA);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setdata got err %d",
bitforce->drv->name, bitforce->device_id, err);
@ -111,7 +112,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -111,7 +112,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
// Set the baud
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD_BFL,
(FTDI_INDEX_BAUD_BFL & 0xff00) | bitforce->usbdev->found->interface,
(FTDI_INDEX_BAUD_BFL & 0xff00) | interface,
C_SETBAUD);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setbaud got err %d",
@ -122,7 +123,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -122,7 +123,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
// Set Flow Control
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, bitforce->usbdev->found->interface, C_SETFLOW);
FTDI_VALUE_FLOW, interface, C_SETFLOW);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
bitforce->drv->name, bitforce->device_id, err);
@ -132,7 +133,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -132,7 +133,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
// Set Modem Control
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, bitforce->usbdev->found->interface, C_SETMODEM);
FTDI_VALUE_MODEM, interface, C_SETMODEM);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
bitforce->drv->name, bitforce->device_id, err);
@ -142,7 +143,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -142,7 +143,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
// Clear any sent data
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_PURGE_TX, bitforce->usbdev->found->interface, C_PURGETX);
FTDI_VALUE_PURGE_TX, interface, C_PURGETX);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: purgetx got err %d",
bitforce->drv->name, bitforce->device_id, err);
@ -152,7 +153,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock) @@ -152,7 +153,7 @@ static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
// Clear any received data
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_PURGE_RX, bitforce->usbdev->found->interface, C_PURGERX);
FTDI_VALUE_PURGE_RX, interface, C_PURGERX);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: purgerx got err %d",
bitforce->drv->name, bitforce->device_id, err);

76
driver-icarus.c

@ -102,7 +102,9 @@ ASSERT1(sizeof(uint32_t) == 4); @@ -102,7 +102,9 @@ ASSERT1(sizeof(uint32_t) == 4);
#define LANCELOT_HASH_TIME 0.0000000025000
#define ASICMINERUSB_HASH_TIME 0.0000000029761
// TODO: What is it?
#define CAIRNSMORE1_HASH_TIME 0.0000000026316
#define CAIRNSMORE1_HASH_TIME 0.0000000027000
// Per FPGA
#define CAIRNSMORE2_HASH_TIME 0.0000000066600
#define NANOSEC 1000000000.0
// Icarus Rev3 doesn't send a completion message when it finishes
@ -208,6 +210,8 @@ struct ICARUS_INFO { @@ -208,6 +210,8 @@ struct ICARUS_INFO {
int work_division;
int fpga_count;
uint32_t nonce_mask;
bool initialised;
};
#define END_CONDITION 0x0000ffff
@ -262,6 +266,7 @@ static void _transfer(struct cgpu_info *icarus, uint8_t request_type, uint8_t bR @@ -262,6 +266,7 @@ static void _transfer(struct cgpu_info *icarus, uint8_t request_type, uint8_t bR
static void icarus_initialise(struct cgpu_info *icarus, int baud)
{
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(icarus->device_data);
uint16_t wValue, wIndex;
enum sub_ident ident;
int interface;
@ -282,6 +287,9 @@ static void icarus_initialise(struct cgpu_info *icarus, int baud) @@ -282,6 +287,9 @@ static void icarus_initialise(struct cgpu_info *icarus, int baud)
case IDENT_CMR2:
usb_set_pps(icarus, BLT_PREF_PACKET);
if (ident == IDENT_CMR2) // Chip hack
interface++;
// Reset
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_RESET, FTDI_VALUE_RESET,
interface, C_RESET);
@ -403,6 +411,8 @@ static void icarus_initialise(struct cgpu_info *icarus, int baud) @@ -403,6 +411,8 @@ static void icarus_initialise(struct cgpu_info *icarus, int baud)
quit(1, "icarus_intialise() called with invalid %s cgid %i ident=%d",
icarus->drv->name, icarus->cgminer_id, ident);
}
info->initialised = true;
}
static void rev(unsigned char *s, size_t l)
@ -537,11 +547,12 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus) @@ -537,11 +547,12 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
case IDENT_AMU:
info->Hs = ASICMINERUSB_HASH_TIME;
break;
// TODO: ?
case IDENT_CMR1:
case IDENT_CMR2:
info->Hs = CAIRNSMORE1_HASH_TIME;
break;
case IDENT_CMR2:
info->Hs = CAIRNSMORE2_HASH_TIME;
break;
default:
quit(1, "Icarus get_options() called with invalid %s ident=%d",
icarus->drv->name, ident);
@ -701,13 +712,16 @@ static void get_options(int this_option_offset, struct cgpu_info *icarus, int *b @@ -701,13 +712,16 @@ static void get_options(int this_option_offset, struct cgpu_info *icarus, int *b
*work_division = 1;
*fpga_count = 1;
break;
// TODO: ?
case IDENT_CMR1:
case IDENT_CMR2:
*baud = ICARUS_IO_SPEED;
*work_division = 2;
*fpga_count = 2;
break;
case IDENT_CMR2:
*baud = ICARUS_IO_SPEED;
*work_division = 1;
*fpga_count = 1;
break;
default:
quit(1, "Icarus get_options() called with invalid %s ident=%d",
icarus->drv->name, ident);
@ -795,6 +809,11 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices @@ -795,6 +809,11 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
hex2bin(ob_bin, golden_ob, sizeof(ob_bin));
info = (struct ICARUS_INFO *)calloc(1, sizeof(struct ICARUS_INFO));
if (unlikely(!info))
quit(1, "Failed to malloc ICARUS_INFO");
icarus->device_data = (void *)info;
tries = 2;
ok = false;
while (!ok && tries-- > 0) {
@ -844,15 +863,6 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices @@ -844,15 +863,6 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
applog(LOG_DEBUG, "%s%d: Init baud=%d work_division=%d fpga_count=%d",
icarus->drv->name, icarus->device_id, baud, work_division, fpga_count);
info = (struct ICARUS_INFO *)malloc(sizeof(struct ICARUS_INFO));
if (unlikely(!info))
quit(1, "Failed to malloc ICARUS_INFO");
icarus->device_data = (void *)info;
// Initialise everything to zero for a new device
memset(info, 0, sizeof(struct ICARUS_INFO));
info->baud = baud;
info->work_division = work_division;
info->fpga_count = fpga_count;
@ -862,12 +872,47 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices @@ -862,12 +872,47 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
timersub(&tv_finish, &tv_start, &(info->golden_tv));
set_timing_mode(this_option_offset, icarus);
if (usb_ident(icarus) == IDENT_CMR2) {
int i;
for (i = 1; i < icarus->usbdev->found->intinfo_count; i++) {
struct cgpu_info *cgtmp;
struct ICARUS_INFO *intmp;
cgtmp = usb_init_intinfo(icarus, i);
if (!cgtmp) {
applog(LOG_ERR, "%s%d: Init failed initinfo %d",
icarus->drv->name, icarus->device_id, i);
continue;
}
cgtmp->usbinfo.usbstat = USB_NOSTAT;
if (!add_cgpu(cgtmp)) {
usb_uninit(cgtmp);
continue;
}
update_usb_stats(cgtmp);
intmp = (struct ICARUS_INFO *)malloc(sizeof(struct ICARUS_INFO));
if (unlikely(!intmp))
quit(1, "Failed2 to malloc ICARUS_INFO");
cgtmp->device_data = (void *)intmp;
// Initialise everything to match
memcpy(intmp, info, sizeof(struct ICARUS_INFO));
}
}
return true;
unshin:
usb_uninit(icarus);
free(info);
icarus->device_data = NULL;
shin:
@ -917,6 +962,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work, @@ -917,6 +962,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
if (icarus->usbinfo.nodev)
return -1;
if (!info->initialised)
icarus_initialise(icarus, info->baud);
elapsed.tv_sec = elapsed.tv_usec = 0;
memset(ob_bin, 0, sizeof(ob_bin));

566
usbutils.c

@ -25,7 +25,23 @@ @@ -25,7 +25,23 @@
#define NOCONTROLDEV(err) ((err) == LIBUSB_ERROR_NO_DEVICE || \
(err) == LIBUSB_ERROR_OTHER)
/*
* WARNING - these assume DEVLOCK(cgpu, pstate) is called first and
* DEVUNLOCK(cgpu, pstate) in called in the same function with the same pstate
* given to DEVLOCK.
* You must call DEVUNLOCK(cgpu, pstate) before exiting the function or it will leave
* the thread Cancelability unrestored
*/
#define DEVLOCK(cgpu, _pth_state) do { \
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &_pth_state); \
wr_lock(cgpu->usbinfo.devlock); \
} while (0)
#define DEVUNLOCK(cgpu, _pth_state) do { \
wr_unlock(cgpu->usbinfo.devlock); \
pthread_setcancelstate(_pth_state, NULL); \
} while (0)
#ifdef USE_BFLSC
#define DRV_BFLSC 1
#endif
@ -70,74 +86,136 @@ @@ -70,74 +86,136 @@
#define USB_READ_MINPOLL 40
#define USB_EPS(_intx, _epinfosx) { \
.interface = _intx, \
.epinfo_count = ARRAY_SIZE(_epinfosx), \
.epinfos = _epinfosx \
}
#ifdef USE_BFLSC
// N.B. transfer size is 512 with USB2.0, but only 64 with USB1.1
static struct usb_endpoints bas_eps[] = {
static struct usb_epinfo bas_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
};
static struct usb_intinfo bas_ints[] = {
USB_EPS(0, bas_epinfos)
};
#endif
#ifdef USE_BITFORCE
// N.B. transfer size is 512 with USB2.0, but only 64 with USB1.1
static struct usb_endpoints bfl_eps[] = {
static struct usb_epinfo bfl_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
};
static struct usb_intinfo bfl_ints[] = {
USB_EPS(0, bfl_epinfos)
};
#endif
#ifdef USE_MODMINER
static struct usb_endpoints mmq_eps[] = {
static struct usb_epinfo mmq_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(3), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(3), 0 }
};
static struct usb_intinfo mmq_ints[] = {
USB_EPS(1, mmq_epinfos)
};
#endif
#ifdef USE_AVALON
static struct usb_endpoints ava_eps[] = {
static struct usb_epinfo ava_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
};
static struct usb_intinfo ava_ints[] = {
USB_EPS(0, ava_epinfos)
};
#endif
#ifdef USE_ICARUS
static struct usb_endpoints ica_eps[] = {
static struct usb_epinfo ica_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(3), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
};
static struct usb_endpoints amu_eps[] = {
static struct usb_intinfo ica_ints[] = {
USB_EPS(0, ica_epinfos)
};
static struct usb_epinfo amu_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(1), 0 }
};
static struct usb_endpoints llt_eps[] = {
static struct usb_intinfo amu_ints[] = {
USB_EPS(0, amu_epinfos)
};
static struct usb_epinfo llt_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
};
static struct usb_endpoints cmr1_eps[] = {
static struct usb_intinfo llt_ints[] = {
USB_EPS(0, llt_epinfos)
};
static struct usb_epinfo cmr1_epinfos[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
/*
Interface 1
};
static struct usb_intinfo cmr1_ints[] = {
USB_EPS(0, cmr1_epinfos)
};
static struct usb_epinfo cmr2_epinfos0[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
};
#ifndef WIN32
static struct usb_epinfo cmr2_epinfos1[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(3), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(4), 0 },
Interface 2
};
static struct usb_epinfo cmr2_epinfos2[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(5), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(6), 0 },
Interface 3
};
static struct usb_epinfo cmr2_epinfos3[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(7), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(8), 0 }
*/
};
static struct usb_endpoints cmr2_eps[] = {
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPI(1), 0 },
{ LIBUSB_TRANSFER_TYPE_BULK, 64, EPO(2), 0 }
#endif
static struct usb_intinfo cmr2_ints[] = {
USB_EPS(0, cmr2_epinfos0)
#ifndef WIN32
,
USB_EPS(1, cmr2_epinfos1),
USB_EPS(2, cmr2_epinfos2),
USB_EPS(3, cmr2_epinfos3)
#endif
};
#endif
#define IDVENDOR_FTDI 0x0403
#define INTINFO(_ints) \
.which_intinfo = 0, \
.intinfo_count = ARRAY_SIZE(_ints), \
.intinfos = _ints
#define USBEP(_usbdev, _epinfo) (_usbdev->found->intinfos[_usbdev->found->which_intinfo].epinfos[_epinfo].ep)
#define FOUNDIF(_found) (_found->intinfos[_found->which_intinfo].interface)
#define USBIF(_usbdev) FOUNDIF(_usbdev->found)
// TODO: Add support for (at least) Isochronous endpoints
static struct usb_find_devices find_dev[] = {
#ifdef USE_BFLSC
@ -149,13 +227,10 @@ static struct usb_find_devices find_dev[] = { @@ -149,13 +227,10 @@ static struct usb_find_devices find_dev[] = {
.idProduct = 0x6014,
//.iManufacturer = "Butterfly Labs",
.iProduct = "BitFORCE SHA256 SC",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = BFLSC_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(bas_eps),
.eps = bas_eps },
INTINFO(bas_ints) },
#endif
#ifdef USE_BITFORCE
{
@ -166,13 +241,10 @@ static struct usb_find_devices find_dev[] = { @@ -166,13 +241,10 @@ static struct usb_find_devices find_dev[] = {
.idProduct = 0x6014,
.iManufacturer = "Butterfly Labs Inc.",
.iProduct = "BitFORCE SHA256",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = BITFORCE_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(bfl_eps),
.eps = bfl_eps },
INTINFO(bfl_ints) },
#endif
#ifdef USE_MODMINER
{
@ -181,13 +253,10 @@ static struct usb_find_devices find_dev[] = { @@ -181,13 +253,10 @@ static struct usb_find_devices find_dev[] = {
.ident = IDENT_MMQ,
.idVendor = 0x1fc9,
.idProduct = 0x0003,
.kernel = 0,
.config = 1,
.interface = 1,
.timeout = MODMINER_TIMEOUT_MS,
.latency = LATENCY_UNUSED,
.epcount = ARRAY_SIZE(mmq_eps),
.eps = mmq_eps },
INTINFO(mmq_ints) },
#endif
#ifdef USE_AVALON
{
@ -198,26 +267,20 @@ static struct usb_find_devices find_dev[] = { @@ -198,26 +267,20 @@ static struct usb_find_devices find_dev[] = {
.idProduct = 0x6001,
.iManufacturer = "Burnin Electronics",
.iProduct = "BitBurner",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = AVALON_TIMEOUT_MS,
.latency = 10,
.epcount = ARRAY_SIZE(ava_eps),
.eps = ava_eps },
INTINFO(ava_ints) },
{
.drv = DRV_AVALON,
.name = "AVA",
.ident = IDENT_AVA,
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x6001,
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = AVALON_TIMEOUT_MS,
.latency = 10,
.epcount = ARRAY_SIZE(ava_eps),
.eps = ava_eps },
INTINFO(ava_ints) },
#endif
#ifdef USE_ICARUS
{
@ -226,26 +289,20 @@ static struct usb_find_devices find_dev[] = { @@ -226,26 +289,20 @@ static struct usb_find_devices find_dev[] = {
.ident = IDENT_ICA,
.idVendor = 0x067b,
.idProduct = 0x2303,
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_UNUSED,
.epcount = ARRAY_SIZE(ica_eps),
.eps = ica_eps },
INTINFO(ica_ints) },
{
.drv = DRV_ICARUS,
.name = "AMU",
.ident = IDENT_AMU,
.idVendor = 0x10c4,
.idProduct = 0xea60,
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_UNUSED,
.epcount = ARRAY_SIZE(amu_eps),
.eps = amu_eps },
INTINFO(amu_ints) },
{
.drv = DRV_ICARUS,
.name = "BLT",
@ -253,13 +310,10 @@ static struct usb_find_devices find_dev[] = { @@ -253,13 +310,10 @@ static struct usb_find_devices find_dev[] = {
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x6001,
.iProduct = "FT232R USB UART",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(llt_eps),
.eps = llt_eps },
INTINFO(llt_ints) },
// For any that don't match the above "BLT"
{
.drv = DRV_ICARUS,
@ -267,41 +321,32 @@ static struct usb_find_devices find_dev[] = { @@ -267,41 +321,32 @@ static struct usb_find_devices find_dev[] = {
.ident = IDENT_LLT,
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x6001,
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(llt_eps),
.eps = llt_eps },
INTINFO(llt_ints) },
{
.drv = DRV_ICARUS,
.name = "CMR",
.ident = IDENT_CMR1,
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x8350,
.idProduct = 0x6014,
.iProduct = "Cairnsmore1",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(cmr1_eps),
.eps = cmr1_eps },
INTINFO(cmr1_ints) },
{
.drv = DRV_ICARUS,
.name = "CMR",
.ident = IDENT_CMR2,
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x6014,
.idProduct = 0x8350,
.iProduct = "Cairnsmore1",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(cmr2_eps),
.eps = cmr2_eps },
INTINFO(cmr2_ints) },
#endif
#ifdef USE_ZTEX
// This is here so cgminer -n shows them
@ -312,15 +357,14 @@ static struct usb_find_devices find_dev[] = { @@ -312,15 +357,14 @@ static struct usb_find_devices find_dev[] = {
.ident = IDENT_ZTX,
.idVendor = 0x221a,
.idProduct = 0x0100,
.kernel = 0,
.config = 1,
.interface = 1,
.timeout = 100,
.latency = LATENCY_UNUSED,
.epcount = 0,
.eps = NULL },
.which_intinfo = 0,
.intinfo_count = 0,
.intinfos = NULL },
#endif
{ DRV_LAST, NULL, 0, 0, 0, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, NULL }
{ DRV_LAST, NULL, 0, 0, 0, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL }
};
#ifdef USE_BFLSC
@ -1340,7 +1384,8 @@ static struct cg_usb_device *free_cgusb(struct cg_usb_device *cgusb) @@ -1340,7 +1384,8 @@ static struct cg_usb_device *free_cgusb(struct cg_usb_device *cgusb)
if (cgusb->prod_string && cgusb->prod_string != BLANK)
free(cgusb->prod_string);
free(cgusb->descriptor);
if (cgusb->descriptor)
free(cgusb->descriptor);
free(cgusb->found);
@ -1352,7 +1397,7 @@ static struct cg_usb_device *free_cgusb(struct cg_usb_device *cgusb) @@ -1352,7 +1397,7 @@ static struct cg_usb_device *free_cgusb(struct cg_usb_device *cgusb)
return NULL;
}
void usb_uninit(struct cgpu_info *cgpu)
static void _usb_uninit(struct cgpu_info *cgpu)
{
applog(LOG_DEBUG, "USB uninit %s%i",
cgpu->drv->name, cgpu->device_id);
@ -1361,14 +1406,28 @@ void usb_uninit(struct cgpu_info *cgpu) @@ -1361,14 +1406,28 @@ void usb_uninit(struct cgpu_info *cgpu)
// if release_cgpu() was called due to a USB NODEV(err)
if (!cgpu->usbdev)
return;
if (!libusb_release_interface(cgpu->usbdev->handle, cgpu->usbdev->found->interface)) {
if (cgpu->usbdev->handle) {
libusb_release_interface(cgpu->usbdev->handle, USBIF(cgpu->usbdev));
cg_wlock(&cgusb_fd_lock);
libusb_close(cgpu->usbdev->handle);
cgpu->usbdev->handle = NULL;
cg_wunlock(&cgusb_fd_lock);
}
cgpu->usbdev = free_cgusb(cgpu->usbdev);
}
void usb_uninit(struct cgpu_info *cgpu)
{
int pstate;
DEVLOCK(cgpu, pstate);
_usb_uninit(cgpu);
DEVUNLOCK(cgpu, pstate);
}
/*
* N.B. this is always called inside
* DEVLOCK(cgpu, pstate);
@ -1377,7 +1436,7 @@ static void release_cgpu(struct cgpu_info *cgpu) @@ -1377,7 +1436,7 @@ static void release_cgpu(struct cgpu_info *cgpu)
{
struct cg_usb_device *cgusb = cgpu->usbdev;
struct cgpu_info *lookcgpu;
int i;
int which_intinfo, i;
applog(LOG_DEBUG, "USB release %s%i",
cgpu->drv->name, cgpu->device_id);
@ -1410,16 +1469,24 @@ static void release_cgpu(struct cgpu_info *cgpu) @@ -1410,16 +1469,24 @@ static void release_cgpu(struct cgpu_info *cgpu)
}
}
usb_uninit(cgpu);
cgminer_usb_unlock_bd(cgpu->drv, cgpu->usbinfo.bus_number, cgpu->usbinfo.device_address);
which_intinfo = cgpu->usbdev->found->which_intinfo;
_usb_uninit(cgpu);
if (which_intinfo == 0)
cgminer_usb_unlock_bd(cgpu->drv, cgpu->usbinfo.bus_number, cgpu->usbinfo.device_address);
}
// Currently only used by MMQ
/*
* Used by MMQ - use the same usbdev thus locking is across all 4 related devices
* since they must use the same USB handle since they use the same interface
*/
struct cgpu_info *usb_copy_cgpu(struct cgpu_info *orig)
{
struct cgpu_info *copy = calloc(1, sizeof(*copy));
struct cgpu_info *copy;
int pstate;
DEVLOCK(orig, pstate);
copy = calloc(1, sizeof(*copy));
if (unlikely(!copy))
quit(1, "Failed to calloc cgpu for %s in usb_copy_cgpu", orig->drv->dname);
@ -1436,6 +1503,75 @@ struct cgpu_info *usb_copy_cgpu(struct cgpu_info *orig) @@ -1436,6 +1503,75 @@ struct cgpu_info *usb_copy_cgpu(struct cgpu_info *orig)
copy->usbinfo.devlock = orig->usbinfo.devlock;
DEVUNLOCK(orig, pstate);
return copy;
}
/*
* Used by CMR - use a different usbdev - since they must use a different
* USB handle due to using different interfaces (libusb requirement)
* N.B. multiple interfaces don't as yet work in windows libusb
* so the CMR defines above that use them are defined out in windows
* Nothing else uses multiple interfaces as at 20130922
*/
static struct cgpu_info *usb_dup_cgpu(struct cgpu_info *orig, int intinfo)
{
struct cgpu_info *copy;
copy = calloc(1, sizeof(*copy));
if (unlikely(!copy))
quit(1, "Failed to calloc cgpu for %s in usb_dup_cgpu", orig->drv->dname);
copy->name = orig->name;
copy->drv = copy_drv(orig->drv);
copy->deven = orig->deven;
copy->threads = orig->threads;
if (orig->usbdev) {
copy->usbdev = calloc(1, sizeof(*(copy->usbdev)));
if (unlikely(!copy->usbdev))
quit(1, "Failed to calloc usbdev for %s in usb_dup_cgpu", orig->drv->dname);
copy->usbdev->found = malloc(sizeof(*(copy->usbdev->found)));
if (unlikely(!copy->usbdev->found))
quit(1, "Failed to malloc found for %s in usb_dup_cgpu", orig->drv->dname);
memcpy(copy->usbdev->found, orig->usbdev->found, sizeof(*(copy->usbdev->found)));
copy->usbdev->found->which_intinfo = intinfo;
copy->usbdev->descriptor = NULL; // don't need it
copy->usbdev->usb_type = orig->usbdev->usb_type;
copy->usbdev->ident = orig->usbdev->ident;
copy->usbdev->usbver = orig->usbdev->usbver;
copy->usbdev->cps = orig->usbdev->cps;
copy->usbdev->usecps = orig->usbdev->usecps;
if (orig->usbdev->prod_string == BLANK)
copy->usbdev->prod_string = (char *)BLANK;
else
copy->usbdev->prod_string = strdup(orig->usbdev->prod_string);
if (orig->usbdev->manuf_string == BLANK)
copy->usbdev->manuf_string = (char *)BLANK;
else
copy->usbdev->manuf_string = strdup(orig->usbdev->manuf_string);
if (orig->usbdev->serial_string == BLANK)
copy->usbdev->serial_string = (char *)BLANK;
else
copy->usbdev->serial_string = strdup(orig->usbdev->serial_string);
copy->usbdev->fwVersion = orig->usbdev->fwVersion;
copy->usbdev->interfaceVersion = orig->usbdev->interfaceVersion;
}
memcpy(&(copy->usbinfo), &(orig->usbinfo), sizeof(copy->usbinfo));
copy->usbinfo.nodev = (copy->usbdev == NULL);
copy->usbinfo.devlock = calloc(1, sizeof(*(copy->usbinfo.devlock)));
if (unlikely(!copy->usbinfo.devlock))
quit(1, "Failed to calloc devlock for %s in usb_dup_cgpu", orig->drv->dname);
rwlock_init(copy->usbinfo.devlock);
return copy;
}
@ -1480,23 +1616,6 @@ struct cgpu_info *usb_free_cgpu_devlock(struct cgpu_info *cgpu, bool free_devloc @@ -1480,23 +1616,6 @@ struct cgpu_info *usb_free_cgpu_devlock(struct cgpu_info *cgpu, bool free_devloc
#define USB_INIT_OK 1
#define USB_INIT_IGNORE 2
/*
* WARNING - these assume DEVLOCK(cgpu, pstate) is called first and
* DEVUNLOCK(cgpu, pstate) in called in the same function with the same pstate
* given to DEVLOCK.
* You must call DEVUNLOCK(cgpu, pstate) before exiting the function or it will leave
* the thread Cancelability unrestored
*/
#define DEVLOCK(cgpu, _pth_state) do { \
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &_pth_state); \
wr_lock(cgpu->usbinfo.devlock); \
} while (0)
#define DEVUNLOCK(cgpu, _pth_state) do { \
wr_unlock(cgpu->usbinfo.devlock); \
pthread_setcancelstate(_pth_state, NULL); \
} while (0)
static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct usb_find_devices *found)
{
struct cg_usb_device *cgusb = NULL;
@ -1506,7 +1625,7 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u @@ -1506,7 +1625,7 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u
unsigned char strbuf[STRBUFLEN+1];
char devpath[32];
char devstr[STRBUFLEN+1];
int err, i, j, k, pstate;
int err, ifinfo, epinfo, alt, epnum, pstate;
int bad = USB_INIT_FAIL;
int cfg;
@ -1515,9 +1634,16 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u @@ -1515,9 +1634,16 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u
cgpu->usbinfo.bus_number = libusb_get_bus_number(dev);
cgpu->usbinfo.device_address = libusb_get_device_address(dev);
snprintf(devpath, sizeof(devpath), "%d:%d",
(int)(cgpu->usbinfo.bus_number),
(int)(cgpu->usbinfo.device_address));
if (found->intinfo_count > 1) {
snprintf(devpath, sizeof(devpath), "%d:%d-i%d",
(int)(cgpu->usbinfo.bus_number),
(int)(cgpu->usbinfo.device_address),
FOUNDIF(found));
} else {
snprintf(devpath, sizeof(devpath), "%d:%d",
(int)(cgpu->usbinfo.bus_number),
(int)(cgpu->usbinfo.device_address));
}
cgpu->device_path = strdup(devpath);
@ -1574,17 +1700,17 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u @@ -1574,17 +1700,17 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u
}
#ifndef WIN32
if (libusb_kernel_driver_active(cgusb->handle, found->kernel) == 1) {
if (libusb_kernel_driver_active(cgusb->handle, FOUNDIF(found)) == 1) {
applog(LOG_DEBUG, "USB init, kernel attached ... %s", devstr);
err = libusb_detach_kernel_driver(cgusb->handle, found->kernel);
err = libusb_detach_kernel_driver(cgusb->handle, FOUNDIF(found));
if (err == 0) {
applog(LOG_DEBUG,
"USB init, kernel detached successfully %s",
devstr);
"USB init, kernel detached interface %d successfully %s",
FOUNDIF(found), devstr);
} else {
applog(LOG_WARNING,
"USB init, kernel detach failed, err %d in use? %s",
err, devstr);
"USB init, kernel detach interface %d failed, err %d in use? %s",
FOUNDIF(found), err, devstr);
goto cldame;
}
}
@ -1662,55 +1788,66 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u @@ -1662,55 +1788,66 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u
goto cldame;
}
if ((int)(config->bNumInterfaces) <= found->interface) {
applog(LOG_DEBUG, "USB init bNumInterfaces <= interface %s",
devstr);
int imax = -1;
for (ifinfo = 0; ifinfo < found->intinfo_count; ifinfo++)
if (found->intinfos[ifinfo].interface > imax)
imax = found->intinfos[ifinfo].interface;
if ((int)(config->bNumInterfaces) <= imax) {
applog(LOG_DEBUG, "USB init bNumInterfaces %d <= interface max %d for %s",
(int)(config->bNumInterfaces), imax, devstr);
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;
found->wMaxPacketSize = epdesc->wMaxPacketSize;
break;
for (ifinfo = 0; ifinfo < found->intinfo_count; ifinfo++)
for (epinfo = 0; epinfo < found->intinfos[ifinfo].epinfo_count; epinfo++)
found->intinfos[ifinfo].epinfos[epinfo].found = false;
for (ifinfo = 0; ifinfo < found->intinfo_count; ifinfo++) {
int interface = found->intinfos[ifinfo].interface;
for (alt = 0; alt < config->interface[interface].num_altsetting; alt++) {
idesc = &(config->interface[interface].altsetting[alt]);
for (epnum = 0; epnum < (int)(idesc->bNumEndpoints); epnum++) {
struct usb_epinfo *epinfos = found->intinfos[ifinfo].epinfos;
epdesc = &(idesc->endpoint[epnum]);
for (epinfo = 0; epinfo < found->intinfos[ifinfo].epinfo_count; epinfo++) {
if (!epinfos[epinfo].found) {
if (epdesc->bmAttributes == epinfos[epinfo].att
&& epdesc->wMaxPacketSize >= epinfos[epinfo].size
&& epdesc->bEndpointAddress == epinfos[epinfo].ep) {
epinfos[epinfo].found = true;
// TODO: it's an ep (not device) attribute
found->wMaxPacketSize = epdesc->wMaxPacketSize;
break;
}
}
}
}
}
}
for (i = 0; i < found->epcount; i++) {
if (found->eps[i].found == false) {
applog(LOG_DEBUG, "USB init found == false %s",
devstr);
goto cldame;
}
}
for (ifinfo = 0; ifinfo < found->intinfo_count; ifinfo++)
for (epinfo = 0; epinfo < found->intinfos[ifinfo].epinfo_count; epinfo++)
if (found->intinfos[ifinfo].epinfos[epinfo].found == false) {
applog(LOG_DEBUG, "USB init found (%d,%d) == false %s",
ifinfo, epinfo, devstr);
goto cldame;
}
err = libusb_claim_interface(cgusb->handle, found->interface);
err = libusb_claim_interface(cgusb->handle, FOUNDIF(found));
if (err) {
switch(err) {
case LIBUSB_ERROR_BUSY:
applog(LOG_WARNING,
"USB init, claim interface %d in use %s",
found->interface, devstr);
FOUNDIF(found), devstr);
break;
default:
applog(LOG_DEBUG,
"USB init, claim interface %d failed, err %d %s",
found->interface, err, devstr);
FOUNDIF(found), err, devstr);
}
goto cldame;
goto reldame;
}
cfg = -1;
@ -1777,12 +1914,13 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u @@ -1777,12 +1914,13 @@ static int _usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct u
reldame:
libusb_release_interface(cgusb->handle, found->interface);
libusb_release_interface(cgusb->handle, FOUNDIF(found));
cldame:
cg_wlock(&cgusb_fd_lock);
libusb_close(cgusb->handle);
cgusb->handle = NULL;
cg_wunlock(&cgusb_fd_lock);
dame:
@ -1798,6 +1936,144 @@ out_unlock: @@ -1798,6 +1936,144 @@ out_unlock:
return bad;
}
// To get the extra interfaces on a multi interface device
struct cgpu_info *usb_init_intinfo(struct cgpu_info *orig, int intinfo)
{
struct usb_find_devices *found;
struct libusb_device *dev;
struct cgpu_info *copy = NULL;
char msgstr[STRBUFLEN+1];
char devstr[STRBUFLEN+1];
char devpath[32];
int err, pstate;
DEVLOCK(orig, pstate);
snprintf(msgstr, sizeof(msgstr), "USB %s init_intinfo (%d:%d-i%d)",
orig->drv->dname,
(int)(orig->usbinfo.bus_number),
(int)(orig->usbinfo.device_address),
orig->usbdev->found->which_intinfo);
if (orig->usbinfo.nodev) {
applog(LOG_ERR, "%s cgpu has nodev", msgstr);
goto Hitagi;
}
if (orig->usbdev->found->which_intinfo != 0) {
applog(LOG_ERR, "%s incorrect cgpu (must be i0)", msgstr);
goto Hitagi;
}
if (orig->usbdev->found->intinfo_count < 2) {
applog(LOG_ERR, "%s cgpu only has 1 interface", msgstr);
goto Hitagi;
}
if (intinfo < 1 || intinfo >= orig->usbdev->found->intinfo_count) {
applog(LOG_ERR, "%s invalid intinfo (%d) must be > 0 && < %d",
msgstr, intinfo, orig->usbdev->found->intinfo_count);
goto Hitagi;
}
dev = libusb_get_device(orig->usbdev->handle);
copy = usb_dup_cgpu(orig, intinfo);
if (!copy)
goto Hitagi;
found = copy->usbdev->found;
snprintf(devpath, sizeof(devpath), "%d:%d-i%d",
(int)(copy->usbinfo.bus_number),
(int)(copy->usbinfo.device_address),
FOUNDIF(found));
copy->device_path = strdup(devpath);
snprintf(devstr, sizeof(devstr), "- %s device %s", found->name, devpath);
cg_wlock(&cgusb_fd_lock);
err = libusb_open(dev, &(copy->usbdev->handle));
cg_wunlock(&cgusb_fd_lock);
if (err) {
switch (err) {
case LIBUSB_ERROR_ACCESS:
applog(LOG_ERR,
"USB init_intinfo, open device failed, err %d, "
"you don't have privilege to access %s",
err, devstr);
break;
#ifdef WIN32
// Windows specific message
case LIBUSB_ERROR_NOT_SUPPORTED:
applog(LOG_ERR,
"USB init_intinfo, open device failed, err %d, "
"you need to install a WinUSB driver for %s",
err, devstr);
break;
#endif
default:
applog(LOG_DEBUG,
"USB init_intinfo, open failed, err %d %s",
err, devstr);
}
goto Hitagi;
}
#ifndef WIN32
if (libusb_kernel_driver_active(copy->usbdev->handle, FOUNDIF(found)) == 1) {
applog(LOG_DEBUG, "USB init_intinfo, kernel attached ... %s", devstr);
err = libusb_detach_kernel_driver(copy->usbdev->handle, FOUNDIF(found));
if (err == 0) {
applog(LOG_DEBUG,
"USB init_intinfo, kernel detached interface %d successfully %s",
FOUNDIF(found), devstr);
} else {
applog(LOG_WARNING,
"USB init_intinfo, kernel detach interface %d failed, err %d in use? %s",
FOUNDIF(found), err, devstr);
goto HitagiClose;
}
}
#endif
err = libusb_claim_interface(copy->usbdev->handle, FOUNDIF(found));
if (err) {
switch(err) {
case LIBUSB_ERROR_BUSY:
applog(LOG_WARNING,
"USB init_intinfo, claim interface %d in use %s",
FOUNDIF(found), devstr);
break;
default:
applog(LOG_DEBUG,
"USB init_intinfo, claim interface %d failed, err %d %s",
FOUNDIF(found), err, devstr);
}
goto HitagiClose;
}
goto Hitagi;
HitagiClose:
cg_wlock(&cgusb_fd_lock);
libusb_close(copy->usbdev->handle);
copy->usbdev->handle = NULL;
cg_wunlock(&cgusb_fd_lock);
copy->usbdev = free_cgusb(copy->usbdev);
copy = usb_free_cgpu(copy);
Hitagi:
DEVUNLOCK(orig, pstate);
return copy;
}
bool usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct usb_find_devices *found_match)
{
struct usb_find_devices *found_use = NULL;
@ -2356,7 +2632,7 @@ usb_bulk_transfer(struct libusb_device_handle *dev_handle, @@ -2356,7 +2632,7 @@ usb_bulk_transfer(struct libusb_device_handle *dev_handle,
return err;
}
int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *processed, unsigned int timeout, const char *end, enum usb_cmds cmd, bool readonce)
int _usb_read(struct cgpu_info *cgpu, int epinfo, char *buf, size_t bufsiz, int *processed, unsigned int timeout, const char *end, enum usb_cmds cmd, bool readonce)
{
struct cg_usb_device *usbdev;
bool ftdi;
@ -2384,7 +2660,7 @@ int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pro @@ -2384,7 +2660,7 @@ int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pro
usbdev = cgpu->usbdev;
ftdi = (usbdev->usb_type == USB_TYPE_FTDI);
USBDEBUG("USB debug: _usb_read(%s (nodev=%s),ep=%d,buf=%p,bufsiz=%zu,proc=%p,timeout=%u,end=%s,cmd=%s,ftdi=%s,readonce=%s)", cgpu->drv->name, bool_str(cgpu->usbinfo.nodev), ep, buf, bufsiz, processed, timeout, end ? (char *)str_text((char *)end) : "NULL", usb_cmdname(cmd), bool_str(ftdi), bool_str(readonce));
USBDEBUG("USB debug: _usb_read(%s (nodev=%s),epinfo=%d,buf=%p,bufsiz=%zu,proc=%p,timeout=%u,end=%s,cmd=%s,ftdi=%s,readonce=%s)", cgpu->drv->name, bool_str(cgpu->usbinfo.nodev), epinfo, buf, bufsiz, processed, timeout, end ? (char *)str_text((char *)end) : "NULL", usb_cmdname(cmd), bool_str(ftdi), bool_str(readonce));
if (bufsiz > USB_MAX_READ)
quit(1, "%s USB read request %d too large (max=%d)", cgpu->drv->name, (int)bufsiz, USB_MAX_READ);
@ -2438,7 +2714,7 @@ int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pro @@ -2438,7 +2714,7 @@ int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pro
}
}
err = usb_bulk_transfer(usbdev->handle,
usbdev->found->eps[ep].ep,
USBEP(usbdev, epinfo),
ptr, usbbufread, &got, timeout,
cgpu, MODE_BULK_READ, cmd, first ? SEQ0 : SEQ1);
cgtime(&tv_finish);
@ -2542,7 +2818,7 @@ int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pro @@ -2542,7 +2818,7 @@ int _usb_read(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pro
}
}
err = usb_bulk_transfer(usbdev->handle,
usbdev->found->eps[ep].ep, ptr,
USBEP(usbdev, epinfo), ptr,
usbbufread, &got, timeout,
cgpu, MODE_BULK_READ, cmd, first ? SEQ0 : SEQ1);
cgtime(&tv_finish);
@ -2629,7 +2905,7 @@ out_unlock: @@ -2629,7 +2905,7 @@ out_unlock:
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)
int _usb_write(struct cgpu_info *cgpu, int epinfo, char *buf, size_t bufsiz, int *processed, unsigned int timeout, enum usb_cmds cmd)
{
struct cg_usb_device *usbdev;
struct timeval read_start, tv_finish;
@ -2640,7 +2916,7 @@ int _usb_write(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pr @@ -2640,7 +2916,7 @@ int _usb_write(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pr
DEVLOCK(cgpu, pstate);
USBDEBUG("USB debug: _usb_write(%s (nodev=%s),ep=%d,buf='%s',bufsiz=%zu,proc=%p,timeout=%u,cmd=%s)", cgpu->drv->name, bool_str(cgpu->usbinfo.nodev), ep, (char *)str_text(buf), bufsiz, processed, timeout, usb_cmdname(cmd));
USBDEBUG("USB debug: _usb_write(%s (nodev=%s),epinfo=%d,buf='%s',bufsiz=%zu,proc=%p,timeout=%u,cmd=%s)", cgpu->drv->name, bool_str(cgpu->usbinfo.nodev), epinfo, (char *)str_text(buf), bufsiz, processed, timeout, usb_cmdname(cmd));
*processed = 0;
@ -2683,7 +2959,7 @@ int _usb_write(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pr @@ -2683,7 +2959,7 @@ int _usb_write(struct cgpu_info *cgpu, int ep, char *buf, size_t bufsiz, int *pr
usbdev->last_write_siz = bufsiz;
}
err = usb_bulk_transfer(usbdev->handle,
usbdev->found->eps[ep].ep,
USBEP(usbdev, epinfo),
(unsigned char *)buf, bufsiz, &sent,
timeout, cgpu, MODE_BULK_WRITE, cmd, first ? SEQ0 : SEQ1);
cgtime(&tv_finish);
@ -2921,7 +3197,7 @@ int usb_ftdi_set_latency(struct cgpu_info *cgpu) @@ -2921,7 +3197,7 @@ int usb_ftdi_set_latency(struct cgpu_info *cgpu)
if (!err)
err = __usb_transfer(cgpu, FTDI_TYPE_OUT, FTDI_REQUEST_LATENCY,
cgpu->usbdev->found->latency,
cgpu->usbdev->found->interface,
USBIF(cgpu->usbdev),
NULL, 0, DEVTIMEOUT, C_LATENCY);
}
@ -3048,7 +3324,7 @@ int usb_interface(struct cgpu_info *cgpu) @@ -3048,7 +3324,7 @@ int usb_interface(struct cgpu_info *cgpu)
DEVLOCK(cgpu, pstate);
if (cgpu->usbdev)
interface = cgpu->usbdev->found->interface;
interface = USBIF(cgpu->usbdev);
DEVUNLOCK(cgpu, pstate);

20
usbutils.h

@ -109,18 +109,24 @@ @@ -109,18 +109,24 @@
// Use the device defined timeout
#define DEVTIMEOUT 0
// For endpoints defined in usb_find_devices.eps,
// the first two must be the default IN and OUT
// For endpoints defined in usb_find_devices.intinfos.epinfos,
// the first two must be the default IN and OUT and both must always exist
#define DEFAULT_EP_IN 0
#define DEFAULT_EP_OUT 1
struct usb_endpoints {
struct usb_epinfo {
uint8_t att;
uint16_t size;
unsigned char ep;
bool found;
};
struct usb_intinfo {
int interface;
int epinfo_count;
struct usb_epinfo *epinfos;
};
enum sub_ident {
IDENT_UNK = 0,
IDENT_BAJ,
@ -148,14 +154,13 @@ struct usb_find_devices { @@ -148,14 +154,13 @@ struct usb_find_devices {
uint16_t idProduct;
char *iManufacturer;
char *iProduct;
int kernel;
int config;
int interface;
unsigned int timeout;
uint16_t wMaxPacketSize;
uint16_t latency;
int epcount;
struct usb_endpoints *eps;
int which_intinfo;
int intinfo_count;
struct usb_intinfo *intinfos;
};
/* Latency is set to 32ms to prevent a transfer ever being more than 512 bytes
@ -330,6 +335,7 @@ struct cgpu_info *usb_alloc_cgpu(struct device_drv *drv, int threads); @@ -330,6 +335,7 @@ struct cgpu_info *usb_alloc_cgpu(struct device_drv *drv, int threads);
struct cgpu_info *usb_free_cgpu_devlock(struct cgpu_info *cgpu, bool free_devlock);
#define usb_free_cgpu(cgpu) usb_free_cgpu_devlock(cgpu, true)
void usb_uninit(struct cgpu_info *cgpu);
struct cgpu_info *usb_init_intinfo(struct cgpu_info *orig, int intinfo);
bool usb_init(struct cgpu_info *cgpu, struct libusb_device *dev, struct usb_find_devices *found);
void usb_detect(struct device_drv *drv, bool (*device_detect)(struct libusb_device *, struct usb_find_devices *));
struct api_data *api_usb_stats(int *count);

Loading…
Cancel
Save