static bool hfa_initialise(struct cgpu_info *hashfast)
{
int err;
if (hashfast->usbinfo.nodev)
return false;
hfa_clear_readbuf(hashfast);
err = usb_transfer(hashfast, 0, 9, 1, 0, C_ATMEL_RESET);
if (!err)
err = usb_transfer(hashfast, 0x21, 0x22, 0, 0, C_ATMEL_OPEN);
if (!err) {
uint32_t buf[2];
/* Magic sequence to reset device only really needed for windows
* but harmless on linux. */
buf[0] = 0x80250000;
buf[1] = 0x00000800;
err = usb_transfer_data(hashfast, 0x21, 0x20, 0x0000, 0, buf,
7, C_ATMEL_INIT);
}
if (err < 0) {
applog(LOG_INFO, "HFA %d: Failed to open with error %s",
hashfast->device_id, libusb_error_name(err));
}
/* Must have transmitted init sequence sized buffer */
return (err == 7);
}
int32_t auc_init(AUC_HANDLE handle, uint32_t clk_rate, uint32_t xfer_delay)
{
struct cdc_i2c_configparams params;
uint8_t buf[CDC_I2C_PACKET_SZ];
struct cdc_i2c_header *pheader = (struct cdc_i2c_header*)buf;
uint32_t i, count;
params.clk_rate[0] = clk_rate & 0xff;
params.clk_rate[1] = (clk_rate >> 8) & 0xff;
params.clk_rate[2] = (clk_rate >> 16) & 0xff;
params.clk_rate[3] = (clk_rate >> 24) & 0xff;
params.xfer_delay[0] = xfer_delay & 0xff;
params.xfer_delay[1] = (xfer_delay >> 8) & 0xff;
params.xfer_delay[2] = (xfer_delay >> 16) & 0xff;
params.xfer_delay[3] = (xfer_delay >> 24) & 0xff;
memset(buf, 0, CDC_I2C_PACKET_SZ);
while (!usb_transfer(handle, NULL, 0, buf, CDC_I2C_PACKET_SZ));
count = auc_pkg_init(CDC_I2C_REQ_INIT_PORT, (uint8_t*)¶ms, sizeof(params));
if (usb_transfer(handle, g_auc_pkg, count, buf, CDC_I2C_PACKET_SZ)) {
printf("auc_init usb_transfer failed!\n");
return 1;
}
for (i = 0; i < AUC_DEVCNT; i++) {
if (handle == auc_devctx.handle[i])
break;
}
if (i >= AUC_DEVCNT) {
printf("auc_init i(%d) > AUC_DEVCNT", i);
return 1;
}
if (pheader->length > CDC_I2C_HEADER_SZ) {
memset(auc_devctx.auc_ver[i], 0, AUC_VERLEN+1);
memcpy(auc_devctx.auc_ver[i], buf + CDC_I2C_HEADER_SZ, AUC_VERLEN);
auc_devctx.auc_ver[i][AUC_VERLEN] = '\0';
} else {
printf("auc_init pheader->length = %d\n", pheader->length);
return 1;
}
return 0;
}
static void bitforce_initialise(struct cgpu_info *bitforce, bool lock)
{
int err;
if (lock)
mutex_lock(&bitforce->device_mutex);
// Reset
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_RESET, bitforce->usbdev->found->interface, C_RESET);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: reset got err %d",
bitforce->drv->name, bitforce->device_id, err);
// Set data control
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
FTDI_VALUE_DATA, bitforce->usbdev->found->interface, C_SETDATA);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setdata got err %d",
bitforce->drv->name, bitforce->device_id, err);
// Set the baud
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD,
(FTDI_INDEX_BAUD & 0xff00) | bitforce->usbdev->found->interface,
C_SETBAUD);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setbaud got err %d",
bitforce->drv->name, bitforce->device_id, err);
// Set Flow Control
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, bitforce->usbdev->found->interface, C_SETFLOW);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
bitforce->drv->name, bitforce->device_id, err);
// Set Modem Control
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, bitforce->usbdev->found->interface, C_SETMODEM);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
bitforce->drv->name, bitforce->device_id, err);
// Clear any sent data
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_PURGE_TX, bitforce->usbdev->found->interface, C_PURGETX);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: purgetx got err %d",
bitforce->drv->name, bitforce->device_id, err);
// Clear any received data
err = usb_transfer(bitforce, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_PURGE_RX, bitforce->usbdev->found->interface, C_PURGERX);
if (opt_debug)
applog(LOG_DEBUG, "%s%i: purgerx got err %d",
bitforce->drv->name, bitforce->device_id, err);
if (lock)
mutex_unlock(&bitforce->device_mutex);
}
int32_t auc_xfer(AUC_HANDLE handle, uint8_t slaveAddr, uint8_t *wbuf, uint32_t wlen, uint8_t *rbuf, uint32_t rlen, uint8_t *respcode)
{
struct cdc_i2c_xferparams params;
uint8_t buf[CDC_I2C_PACKET_SZ];
struct cdc_i2c_header *pheader = (struct cdc_i2c_header *)buf;
int32_t count;
while ((wlen > 0) || (rlen > 0)) {
memset(¶ms, 0, sizeof(params));
if (wlen >= CDC_I2C_PAYLOAD_SZ) {
params.txLength = CDC_I2C_PAYLOAD_SZ;
wlen -= CDC_I2C_PAYLOAD_SZ;
} else {
params.txLength = wlen;
wlen = 0;
}
if (rlen >= (CDC_I2C_PACKET_SZ - CDC_I2C_HEADER_SZ)) {
params.rxLength = (CDC_I2C_PACKET_SZ - CDC_I2C_HEADER_SZ);
rlen -= (CDC_I2C_PACKET_SZ - CDC_I2C_HEADER_SZ);
} else {
params.rxLength = rlen;
rlen = 0;
}
params.reserved = 0;
params.slaveAddr = slaveAddr;
if (params.txLength)
memcpy(params.data, wbuf, params.txLength);
memset(buf, 0, CDC_I2C_PACKET_SZ);
count = auc_pkg_init(CDC_I2C_REQ_DEVICE_XFER, (uint8_t*)¶ms, params.txLength + sizeof(struct cdc_i2c_header));
if (usb_transfer(handle, g_auc_pkg, count, buf, CDC_I2C_PACKET_SZ)) {
#ifdef DEBUG_VERBOSE
printf("auc_xfer usb_transfer failed!\n");
#endif
return 0;
}
if (pheader->length > CDC_I2C_HEADER_SZ)
memcpy(rbuf, buf + CDC_I2C_HEADER_SZ, pheader->length - CDC_I2C_HEADER_SZ);
#ifdef DEBUG_VERBOSE
else {
printf("auc_xfer pheader->length = %d\n", pheader->length);
}
#endif
wbuf += CDC_I2C_PAYLOAD_SZ;
rbuf += (CDC_I2C_PACKET_SZ - CDC_I2C_HEADER_SZ);
}
if (respcode)
*respcode = buf[CDC_I2C_HEADER_SZ - 1];
return pheader->length - CDC_I2C_HEADER_SZ;
}
int32_t auc_deinit(AUC_HANDLE handle)
{
uint32_t count;
uint8_t buf[CDC_I2C_HEADER_SZ];
memset(buf, 0, CDC_I2C_HEADER_SZ);
count = auc_pkg_init(CDC_I2C_REQ_DEINIT_PORT, NULL, 0);
if (usb_transfer(handle, g_auc_pkg, count, buf, CDC_I2C_HEADER_SZ)) {
printf("auc_deinit usb_transfer failed!\n");
return 1;
}
return 0;
}
static int gridseed_ftdi_init(struct cgpu_info *gridseed, int interface)
{
int err;
// Reset
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_RESET, interface, C_RESET);
applog(LOG_DEBUG, "%s%i: reset got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
// Set latency
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_LATENCY,
GRIDSEED_LATENCY, interface, C_LATENCY);
applog(LOG_DEBUG, "%s%i: latency got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
// Set data
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
FTDI_VALUE_DATA_AVA, interface, C_SETDATA);
applog(LOG_DEBUG, "%s%i: data got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
// Set the baud
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD_AVA,
(FTDI_INDEX_BAUD_AVA & 0xff00) | interface,
C_SETBAUD);
applog(LOG_DEBUG, "%s%i: setbaud got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
// Set Modem Control
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, interface, C_SETMODEM);
applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
// Set Flow Control
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, interface, C_SETFLOW);
applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
/* Avalon repeats the following */
// Set Modem Control
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, interface, C_SETMODEM);
applog(LOG_DEBUG, "%s%i: setmodemctrl 2 got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
// Set Flow Control
err = usb_transfer(gridseed, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, interface, C_SETFLOW);
applog(LOG_DEBUG, "%s%i: setflowctrl 2 got err %d",
gridseed->drv->name, gridseed->device_id, err);
if (gridseed->usbinfo.nodev)
return -1;
return 0;
}
static void hashratio_initialise(struct cgpu_info *hashratio)
{
int err, interface;
if (hashratio->usbinfo.nodev)
return;
interface = usb_interface(hashratio);
// Reset
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
FTDI_VALUE_RESET, interface, C_RESET);
applog(LOG_DEBUG, "%s%i: reset got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
// Set latency
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_LATENCY,
HASHRATIO_LATENCY, interface, C_LATENCY);
applog(LOG_DEBUG, "%s%i: latency got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
// Set data
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
FTDI_VALUE_DATA_AVA, interface, C_SETDATA);
applog(LOG_DEBUG, "%s%i: data got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
// Set the baud
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD_AVA,
(FTDI_INDEX_BAUD_AVA & 0xff00) | interface,
C_SETBAUD);
applog(LOG_DEBUG, "%s%i: setbaud got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
// Set Modem Control
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, interface, C_SETMODEM);
applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
// Set Flow Control
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, interface, C_SETFLOW);
applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
/* hashratio repeats the following */
// Set Modem Control
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
FTDI_VALUE_MODEM, interface, C_SETMODEM);
applog(LOG_DEBUG, "%s%i: setmodemctrl 2 got err %d",
hashratio->drv->name, hashratio->device_id, err);
if (hashratio->usbinfo.nodev)
return;
// Set Flow Control
err = usb_transfer(hashratio, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
FTDI_VALUE_FLOW, interface, C_SETFLOW);
applog(LOG_DEBUG, "%s%i: setflowctrl 2 got err %d",
hashratio->drv->name, hashratio->device_id, err);
}
