mirror of https://github.com/GOSTSec/sgminer
ckolivas
11 years ago
committed by
Con Kolivas
18 changed files with 6 additions and 1542 deletions
@ -1,24 +0,0 @@
@@ -1,24 +0,0 @@
|
||||
All the bitstream files included in this directory that follow the name pattern ztex_*.bit are: |
||||
|
||||
---- |
||||
|
||||
Copyright (C) 2009-2011 ZTEX GmbH. |
||||
http://www.ztex.de |
||||
|
||||
|
||||
This program is free software; you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License version 3 as |
||||
published by the Free Software Foundation. |
||||
|
||||
This program is distributed in the hope that it will be useful, but |
||||
WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program; if not, see http://www.gnu.org/licenses/. |
||||
|
||||
---- |
||||
|
||||
You can find the original sources at the BTCMiner project home page: http://www.ztex.de/btcminer/ |
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -1,423 +0,0 @@
@@ -1,423 +0,0 @@
|
||||
/**
|
||||
* ztex.c - cgminer worker for Ztex 1.15x fpga board |
||||
* |
||||
* Copyright (c) 2012 nelisky.btc@gmail.com |
||||
* |
||||
* This work is based upon the Java SDK provided by ztex which is |
||||
* Copyright (C) 2009-2011 ZTEX GmbH. |
||||
* http://www.ztex.de
|
||||
* |
||||
* This work is based upon the icarus.c worker which was |
||||
* Copyright 2012 Luke Dashjr |
||||
* Copyright 2012 Xiangfu <xiangfu@openmobilefree.com> |
||||
* |
||||
* This program is free software; you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License version 2 as |
||||
* published by the Free Software Foundation. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, but |
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, see http://www.gnu.org/licenses/.
|
||||
**/ |
||||
#include "miner.h" |
||||
#include <unistd.h> |
||||
#include <sha2.h> |
||||
#include "libztex.h" |
||||
#include "util.h" |
||||
|
||||
#define GOLDEN_BACKLOG 5 |
||||
|
||||
// Forward declarations
|
||||
static void ztex_disable(struct thr_info* thr); |
||||
static bool ztex_prepare(struct thr_info *thr); |
||||
|
||||
static void ztex_selectFpga(struct libztex_device* ztex) |
||||
{ |
||||
if (ztex->root->numberOfFpgas > 1) { |
||||
if (ztex->root->selectedFpga != ztex->fpgaNum) |
||||
mutex_lock(&ztex->root->mutex); |
||||
libztex_selectFpga(ztex); |
||||
} |
||||
} |
||||
|
||||
static void ztex_releaseFpga(struct libztex_device* ztex) |
||||
{ |
||||
if (ztex->root->numberOfFpgas > 1) { |
||||
ztex->root->selectedFpga = -1; |
||||
mutex_unlock(&ztex->root->mutex); |
||||
} |
||||
} |
||||
|
||||
static void ztex_detect(bool __maybe_unused hotplug) |
||||
{ |
||||
int cnt; |
||||
int i,j; |
||||
int fpgacount; |
||||
struct libztex_dev_list **ztex_devices; |
||||
struct libztex_device *ztex_slave; |
||||
struct cgpu_info *ztex; |
||||
|
||||
cnt = libztex_scanDevices(&ztex_devices); |
||||
if (cnt > 0) |
||||
applog(LOG_WARNING, "Found %d ztex board%s", cnt, cnt > 1 ? "s" : ""); |
||||
|
||||
for (i = 0; i < cnt; i++) { |
||||
ztex = calloc(1, sizeof(struct cgpu_info)); |
||||
ztex->drv = &ztex_drv; |
||||
ztex->device_ztex = ztex_devices[i]->dev; |
||||
ztex->threads = 1; |
||||
ztex->device_ztex->fpgaNum = 0; |
||||
ztex->device_ztex->root = ztex->device_ztex; |
||||
add_cgpu(ztex); |
||||
|
||||
fpgacount = libztex_numberOfFpgas(ztex->device_ztex); |
||||
|
||||
if (fpgacount > 1) |
||||
pthread_mutex_init(&ztex->device_ztex->mutex, NULL); |
||||
|
||||
for (j = 1; j < fpgacount; j++) { |
||||
ztex = calloc(1, sizeof(struct cgpu_info)); |
||||
ztex->drv = &ztex_drv; |
||||
ztex_slave = calloc(1, sizeof(struct libztex_device)); |
||||
memcpy(ztex_slave, ztex_devices[i]->dev, sizeof(struct libztex_device)); |
||||
ztex->device_ztex = ztex_slave; |
||||
ztex->threads = 1; |
||||
ztex_slave->fpgaNum = j; |
||||
ztex_slave->root = ztex_devices[i]->dev; |
||||
ztex_slave->repr[strlen(ztex_slave->repr) - 1] = ('1' + j); |
||||
add_cgpu(ztex); |
||||
} |
||||
|
||||
applog(LOG_WARNING,"%s: Found Ztex (fpga count = %d) , mark as %d", ztex->device_ztex->repr, fpgacount, ztex->device_id); |
||||
} |
||||
|
||||
if (cnt > 0) |
||||
libztex_freeDevList(ztex_devices); |
||||
} |
||||
|
||||
static bool ztex_updateFreq(struct libztex_device* ztex) |
||||
{ |
||||
int i, maxM, bestM; |
||||
double bestR, r; |
||||
|
||||
for (i = 0; i < ztex->freqMaxM; i++) |
||||
if (ztex->maxErrorRate[i + 1] * i < ztex->maxErrorRate[i] * (i + 20)) |
||||
ztex->maxErrorRate[i + 1] = ztex->maxErrorRate[i] * (1.0 + 20.0 / i); |
||||
|
||||
maxM = 0; |
||||
while (maxM < ztex->freqMDefault && ztex->maxErrorRate[maxM + 1] < LIBZTEX_MAXMAXERRORRATE) |
||||
maxM++; |
||||
while (maxM < ztex->freqMaxM && ztex->errorWeight[maxM] > 150 && ztex->maxErrorRate[maxM + 1] < LIBZTEX_MAXMAXERRORRATE) |
||||
maxM++; |
||||
|
||||
bestM = 0; |
||||
bestR = 0; |
||||
for (i = 0; i <= maxM; i++) { |
||||
r = (i + 1 + (i == ztex->freqM? LIBZTEX_ERRORHYSTERESIS: 0)) * (1 - ztex->maxErrorRate[i]); |
||||
if (r > bestR) { |
||||
bestM = i; |
||||
bestR = r; |
||||
} |
||||
} |
||||
|
||||
if (bestM != ztex->freqM) { |
||||
ztex_selectFpga(ztex); |
||||
libztex_setFreq(ztex, bestM); |
||||
ztex_releaseFpga(ztex); |
||||
} |
||||
|
||||
maxM = ztex->freqMDefault; |
||||
while (maxM < ztex->freqMaxM && ztex->errorWeight[maxM + 1] > 100) |
||||
maxM++; |
||||
if ((bestM < (1.0 - LIBZTEX_OVERHEATTHRESHOLD) * maxM) && bestM < maxM - 1) { |
||||
ztex_selectFpga(ztex); |
||||
libztex_resetFpga(ztex); |
||||
ztex_releaseFpga(ztex); |
||||
applog(LOG_ERR, "%s: frequency drop of %.1f%% detect. This may be caused by overheating. FPGA is shut down to prevent damage.", |
||||
ztex->repr, (1.0 - 1.0 * bestM / maxM) * 100); |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
static uint32_t ztex_checkNonce(struct work *work, uint32_t nonce) |
||||
{ |
||||
uint32_t *data32 = (uint32_t *)(work->data); |
||||
unsigned char swap[80]; |
||||
uint32_t *swap32 = (uint32_t *)swap; |
||||
unsigned char hash1[32]; |
||||
unsigned char hash2[32]; |
||||
uint32_t *hash2_32 = (uint32_t *)hash2; |
||||
int i; |
||||
|
||||
swap32[76/4] = htonl(nonce); |
||||
|
||||
for (i = 0; i < 76 / 4; i++) |
||||
swap32[i] = swab32(data32[i]); |
||||
|
||||
sha256(swap, 80, hash1); |
||||
sha256(hash1, 32, hash2); |
||||
|
||||
return htonl(hash2_32[7]); |
||||
} |
||||
|
||||
static int64_t ztex_scanhash(struct thr_info *thr, struct work *work, |
||||
__maybe_unused int64_t max_nonce) |
||||
{ |
||||
struct libztex_device *ztex; |
||||
unsigned char sendbuf[44]; |
||||
int i, j, k; |
||||
uint32_t *backlog; |
||||
int backlog_p = 0, backlog_max; |
||||
uint32_t *lastnonce; |
||||
uint32_t nonce, noncecnt = 0; |
||||
bool overflow, found; |
||||
struct libztex_hash_data hdata[GOLDEN_BACKLOG]; |
||||
|
||||
if (thr->cgpu->deven == DEV_DISABLED) |
||||
return -1; |
||||
|
||||
ztex = thr->cgpu->device_ztex; |
||||
|
||||
memcpy(sendbuf, work->data + 64, 12); |
||||
memcpy(sendbuf + 12, work->midstate, 32); |
||||
|
||||
ztex_selectFpga(ztex); |
||||
i = libztex_sendHashData(ztex, sendbuf); |
||||
if (i < 0) { |
||||
// Something wrong happened in send
|
||||
applog(LOG_ERR, "%s: Failed to send hash data with err %d, retrying", ztex->repr, i); |
||||
cgsleep_ms(500); |
||||
i = libztex_sendHashData(ztex, sendbuf); |
||||
if (i < 0) { |
||||
// And there's nothing we can do about it
|
||||
ztex_disable(thr); |
||||
applog(LOG_ERR, "%s: Failed to send hash data with err %d, giving up", ztex->repr, i); |
||||
ztex_releaseFpga(ztex); |
||||
return -1; |
||||
} |
||||
} |
||||
ztex_releaseFpga(ztex); |
||||
|
||||
applog(LOG_DEBUG, "%s: sent hashdata", ztex->repr); |
||||
|
||||
lastnonce = calloc(1, sizeof(uint32_t)*ztex->numNonces); |
||||
if (lastnonce == NULL) { |
||||
applog(LOG_ERR, "%s: failed to allocate lastnonce[%d]", ztex->repr, ztex->numNonces); |
||||
return -1; |
||||
} |
||||
|
||||
/* Add an extra slot for detecting dupes that lie around */ |
||||
backlog_max = ztex->numNonces * (2 + ztex->extraSolutions); |
||||
backlog = calloc(1, sizeof(uint32_t) * backlog_max); |
||||
if (backlog == NULL) { |
||||
applog(LOG_ERR, "%s: failed to allocate backlog[%d]", ztex->repr, backlog_max); |
||||
return -1; |
||||
} |
||||
|
||||
overflow = false; |
||||
int count = 0; |
||||
int validNonces = 0; |
||||
double errorCount = 0; |
||||
|
||||
applog(LOG_DEBUG, "%s: entering poll loop", ztex->repr); |
||||
while (!(overflow || thr->work_restart)) { |
||||
count++; |
||||
|
||||
int sleepcount = 0; |
||||
while (thr->work_restart == 0 && sleepcount < 25) { |
||||
cgsleep_ms(10); |
||||
sleepcount += 1; |
||||
} |
||||
|
||||
if (thr->work_restart) { |
||||
applog(LOG_DEBUG, "%s: New work detected", ztex->repr); |
||||
break; |
||||
} |
||||
|
||||
ztex_selectFpga(ztex); |
||||
i = libztex_readHashData(ztex, &hdata[0]); |
||||
if (i < 0) { |
||||
// Something wrong happened in read
|
||||
applog(LOG_ERR, "%s: Failed to read hash data with err %d, retrying", ztex->repr, i); |
||||
cgsleep_ms(500); |
||||
i = libztex_readHashData(ztex, &hdata[0]); |
||||
if (i < 0) { |
||||
// And there's nothing we can do about it
|
||||
ztex_disable(thr); |
||||
applog(LOG_ERR, "%s: Failed to read hash data with err %d, giving up", ztex->repr, i); |
||||
free(lastnonce); |
||||
free(backlog); |
||||
ztex_releaseFpga(ztex); |
||||
return -1; |
||||
} |
||||
} |
||||
ztex_releaseFpga(ztex); |
||||
|
||||
if (thr->work_restart) { |
||||
applog(LOG_DEBUG, "%s: New work detected", ztex->repr); |
||||
break; |
||||
} |
||||
|
||||
ztex->errorCount[ztex->freqM] *= 0.995; |
||||
ztex->errorWeight[ztex->freqM] = ztex->errorWeight[ztex->freqM] * 0.995 + 1.0; |
||||
|
||||
for (i = 0; i < ztex->numNonces; i++) { |
||||
nonce = hdata[i].nonce; |
||||
if (nonce > noncecnt) |
||||
noncecnt = nonce; |
||||
if (((0xffffffff - nonce) < (nonce - lastnonce[i])) || nonce < lastnonce[i]) { |
||||
applog(LOG_DEBUG, "%s: overflow nonce=%08x lastnonce=%08x", ztex->repr, nonce, lastnonce[i]); |
||||
overflow = true; |
||||
} else |
||||
lastnonce[i] = nonce; |
||||
|
||||
if (ztex_checkNonce(work, nonce) != (hdata->hash7 + 0x5be0cd19)) { |
||||
applog(LOG_DEBUG, "%s: checkNonce failed for %08X", ztex->repr, nonce); |
||||
|
||||
// do not count errors in the first 500ms after sendHashData (2x250 wait time)
|
||||
if (count > 2) { |
||||
thr->cgpu->hw_errors++; |
||||
errorCount += (1.0 / ztex->numNonces); |
||||
} |
||||
} |
||||
else |
||||
validNonces++; |
||||
|
||||
|
||||
for (j=0; j<=ztex->extraSolutions; j++) { |
||||
nonce = hdata[i].goldenNonce[j]; |
||||
|
||||
if (nonce == ztex->offsNonces) { |
||||
continue; |
||||
} |
||||
|
||||
// precheck the extraSolutions since they often fail
|
||||
if (j > 0 && ztex_checkNonce(work, nonce) != 0) { |
||||
continue; |
||||
} |
||||
|
||||
found = false; |
||||
for (k = 0; k < backlog_max; k++) { |
||||
if (backlog[k] == nonce) { |
||||
found = true; |
||||
break; |
||||
} |
||||
} |
||||
if (!found) { |
||||
applog(LOG_DEBUG, "%s: Share found N%dE%d", ztex->repr, i, j); |
||||
backlog[backlog_p++] = nonce; |
||||
|
||||
if (backlog_p >= backlog_max) |
||||
backlog_p = 0; |
||||
|
||||
work->blk.nonce = 0xffffffff; |
||||
submit_nonce(thr, work, nonce); |
||||
applog(LOG_DEBUG, "%s: submitted %08x", ztex->repr, nonce); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// only add the errorCount if we had at least some valid nonces or
|
||||
// had no valid nonces in the last round
|
||||
if (errorCount > 0.0) { |
||||
if (ztex->nonceCheckValid > 0 && validNonces == 0) { |
||||
applog(LOG_ERR, "%s: resetting %.1f errors", ztex->repr, errorCount); |
||||
} |
||||
else { |
||||
ztex->errorCount[ztex->freqM] += errorCount; |
||||
} |
||||
} |
||||
|
||||
// remember the number of valid nonces for the check in the next round
|
||||
ztex->nonceCheckValid = validNonces; |
||||
|
||||
ztex->errorRate[ztex->freqM] = ztex->errorCount[ztex->freqM] / ztex->errorWeight[ztex->freqM] * (ztex->errorWeight[ztex->freqM] < 100? ztex->errorWeight[ztex->freqM] * 0.01: 1.0); |
||||
if (ztex->errorRate[ztex->freqM] > ztex->maxErrorRate[ztex->freqM]) |
||||
ztex->maxErrorRate[ztex->freqM] = ztex->errorRate[ztex->freqM]; |
||||
|
||||
if (!ztex_updateFreq(ztex)) { |
||||
// Something really serious happened, so mark this thread as dead!
|
||||
free(lastnonce); |
||||
free(backlog); |
||||
|
||||
return -1; |
||||
} |
||||
|
||||
applog(LOG_DEBUG, "%s: exit %1.8X", ztex->repr, noncecnt); |
||||
|
||||
work->blk.nonce = 0xffffffff; |
||||
|
||||
free(lastnonce); |
||||
free(backlog); |
||||
|
||||
return noncecnt; |
||||
} |
||||
|
||||
static void ztex_statline_before(char *buf, size_t bufsiz, struct cgpu_info *cgpu) |
||||
{ |
||||
if (cgpu->deven == DEV_ENABLED) { |
||||
tailsprintf(buf, bufsiz, "%s-%d | ", cgpu->device_ztex->snString, cgpu->device_ztex->fpgaNum+1); |
||||
tailsprintf(buf, bufsiz, "%0.1fMHz | ", cgpu->device_ztex->freqM1 * (cgpu->device_ztex->freqM + 1)); |
||||
} |
||||
} |
||||
|
||||
static bool ztex_prepare(struct thr_info *thr) |
||||
{ |
||||
struct cgpu_info *cgpu = thr->cgpu; |
||||
struct libztex_device *ztex = cgpu->device_ztex; |
||||
|
||||
ztex_selectFpga(ztex); |
||||
if (libztex_configureFpga(ztex) != 0) { |
||||
libztex_resetFpga(ztex); |
||||
ztex_releaseFpga(ztex); |
||||
applog(LOG_ERR, "%s: Disabling!", thr->cgpu->device_ztex->repr); |
||||
thr->cgpu->deven = DEV_DISABLED; |
||||
return true; |
||||
} |
||||
ztex->freqM = ztex->freqMaxM+1;; |
||||
//ztex_updateFreq(ztex);
|
||||
libztex_setFreq(ztex, ztex->freqMDefault); |
||||
ztex_releaseFpga(ztex); |
||||
applog(LOG_DEBUG, "%s: prepare", ztex->repr); |
||||
return true; |
||||
} |
||||
|
||||
static void ztex_shutdown(struct thr_info *thr) |
||||
{ |
||||
if (thr->cgpu->device_ztex != NULL) { |
||||
if (thr->cgpu->device_ztex->fpgaNum == 0) |
||||
pthread_mutex_destroy(&thr->cgpu->device_ztex->mutex); |
||||
applog(LOG_DEBUG, "%s: shutdown", thr->cgpu->device_ztex->repr); |
||||
libztex_destroy_device(thr->cgpu->device_ztex); |
||||
thr->cgpu->device_ztex = NULL; |
||||
} |
||||
} |
||||
|
||||
static void ztex_disable(struct thr_info *thr) |
||||
{ |
||||
struct cgpu_info *cgpu; |
||||
|
||||
applog(LOG_ERR, "%s: Disabling!", thr->cgpu->device_ztex->repr); |
||||
cgpu = get_devices(thr->cgpu->device_id); |
||||
cgpu->deven = DEV_DISABLED; |
||||
ztex_shutdown(thr); |
||||
} |
||||
|
||||
struct device_drv ztex_drv = { |
||||
.drv_id = DRIVER_ztex, |
||||
.dname = "ztex", |
||||
.name = "ZTX", |
||||
.drv_detect = ztex_detect, |
||||
.get_statline_before = ztex_statline_before, |
||||
.thread_prepare = ztex_prepare, |
||||
.scanhash = ztex_scanhash, |
||||
.thread_shutdown = ztex_shutdown, |
||||
}; |
||||
|
||||
@ -1,915 +0,0 @@
@@ -1,915 +0,0 @@
|
||||
/**
|
||||
* libztex.c - Ztex 1.15x/1.15y fpga board support library |
||||
* |
||||
* Copyright (c) 2012 nelisky.btc@gmail.com |
||||
* Copyright (c) 2012 Denis Ahrens <denis@h3q.com> |
||||
* Copyright (c) 2012 Peter Stuge <peter@stuge.se> |
||||
* |
||||
* This work is based upon the Java SDK provided by ztex which is |
||||
* Copyright (C) 2009-2011 ZTEX GmbH. |
||||
* http://www.ztex.de
|
||||
* |
||||
* This program is free software; you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License version 2 as |
||||
* published by the Free Software Foundation. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, but |
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, see http://www.gnu.org/licenses/.
|
||||
**/ |
||||
|
||||
#include "config.h" |
||||
|
||||
#include <stdio.h> |
||||
#include <unistd.h> |
||||
#include <string.h> |
||||
|
||||
#include "miner.h" |
||||
#include "fpgautils.h" |
||||
#include "libztex.h" |
||||
|
||||
//* Capability index for EEPROM support.
|
||||
#define CAPABILITY_EEPROM 0,0 |
||||
//* Capability index for FPGA configuration support.
|
||||
#define CAPABILITY_FPGA 0,1 |
||||
//* Capability index for FLASH memory support.
|
||||
#define CAPABILITY_FLASH 0,2 |
||||
//* Capability index for DEBUG helper support.
|
||||
#define CAPABILITY_DEBUG 0,3 |
||||
//* Capability index for AVR XMEGA support.
|
||||
#define CAPABILITY_XMEGA 0,4 |
||||
//* Capability index for AVR XMEGA support.
|
||||
#define CAPABILITY_HS_FPGA 0,5 |
||||
//* Capability index for AVR XMEGA support.
|
||||
#define CAPABILITY_MAC_EEPROM 0,6 |
||||
//* Capability index for multi FPGA support.
|
||||
#define CAPABILITY_MULTI_FPGA 0,7 |
||||
|
||||
static int libztex_get_string_descriptor_ascii(libusb_device_handle *dev, uint8_t desc_index, |
||||
unsigned char *data, int length) |
||||
{ |
||||
int i, cnt; |
||||
uint16_t langid; |
||||
unsigned char buf[260]; |
||||
|
||||
/* We open code string descriptor retrieval and ASCII decoding here
|
||||
* in order to work around that libusb_get_string_descriptor_ascii() |
||||
* in the FreeBSD libusb implementation hits a bug in ZTEX firmware, |
||||
* where the device returns more bytes than requested, causing babble, |
||||
* which makes FreeBSD return an error to us. |
||||
* |
||||
* Avoid the mess by doing it manually the same way as libusb-1.0. |
||||
*/ |
||||
|
||||
cnt = libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN, |
||||
LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | 0, |
||||
0x0000, buf, sizeof(buf), 1000); |
||||
if (cnt < 0) { |
||||
applog(LOG_ERR, "%s: Failed to read LANGIDs: %d", __func__, cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
langid = libusb_le16_to_cpu(((uint16_t *)buf)[1]); |
||||
|
||||
cnt = libusb_control_transfer(dev, LIBUSB_ENDPOINT_IN, |
||||
LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc_index, |
||||
langid, buf, sizeof(buf), 1000); |
||||
if (cnt < 0) { |
||||
applog(LOG_ERR, "%s: Failed to read string descriptor: %d", __func__, cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
/* num chars = (all bytes except bLength and bDescriptorType) / 2 */ |
||||
for (i = 0; i <= (cnt - 2) / 2 && i < length-1; i++) |
||||
data[i] = buf[2 + i*2]; |
||||
|
||||
data[i] = 0; |
||||
|
||||
return LIBUSB_SUCCESS; |
||||
} |
||||
|
||||
enum check_result |
||||
{ |
||||
CHECK_ERROR, |
||||
CHECK_IS_NOT_ZTEX, |
||||
CHECK_OK, |
||||
CHECK_RESCAN, |
||||
}; |
||||
|
||||
static bool libztex_firmwareReset(struct libusb_device_handle *hndl, bool enable) |
||||
{ |
||||
uint8_t reset = enable; |
||||
int cnt = libusb_control_transfer(hndl, 0x40, 0xA0, 0xE600, 0, &reset, 1, 1000); |
||||
if (cnt < 0) |
||||
{ |
||||
applog(LOG_ERR, "Ztex reset %d failed: %d", enable, cnt); |
||||
return 1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static enum check_result libztex_checkDevice(struct libusb_device *dev) |
||||
{ |
||||
FILE *fp = NULL; |
||||
libusb_device_handle *hndl = NULL; |
||||
struct libusb_device_descriptor desc; |
||||
int ret = CHECK_ERROR, err, cnt; |
||||
size_t got_bytes, length; |
||||
unsigned char buf[64], *fw_buf; |
||||
unsigned int i; |
||||
|
||||
err = libusb_get_device_descriptor(dev, &desc); |
||||
if (unlikely(err != 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to open read descriptor with error %d", err); |
||||
return CHECK_ERROR; |
||||
} |
||||
|
||||
if (desc.idVendor != LIBZTEX_IDVENDOR || desc.idProduct != LIBZTEX_IDPRODUCT) { |
||||
applog(LOG_DEBUG, "Not a ZTEX device %04x:%04x", desc.idVendor, desc.idProduct); |
||||
return CHECK_IS_NOT_ZTEX; |
||||
} |
||||
|
||||
err = libusb_open(dev, &hndl); |
||||
if (err != LIBUSB_SUCCESS) { |
||||
applog(LOG_ERR, "%s: Can not open ZTEX device: %d", __func__, err); |
||||
goto done; |
||||
} |
||||
|
||||
cnt = libusb_control_transfer(hndl, 0xc0, 0x22, 0, 0, buf, 40, 500); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to read ztex descriptor with err %d", cnt); |
||||
goto done; |
||||
} |
||||
|
||||
if (buf[0] != 40 || buf[1] != 1 || buf[2] != 'Z' || buf[3] != 'T' || buf[4] != 'E' || buf[5] != 'X') { |
||||
applog(LOG_ERR, "Ztex check device: Error reading ztex descriptor"); |
||||
goto done; |
||||
} |
||||
|
||||
if (buf[6] != 10) |
||||
{ |
||||
ret = CHECK_IS_NOT_ZTEX; |
||||
goto done; |
||||
} |
||||
|
||||
// 15 = 1.15y 13 = 1.15d or 1.15x
|
||||
switch(buf[7]) |
||||
{ |
||||
case 13: |
||||
applog(LOG_ERR, "Found ztex board 1.15d or 1.15x"); |
||||
break; |
||||
case 15: |
||||
applog(LOG_ERR, "Found ztex board 1.15y"); |
||||
break; |
||||
default: |
||||
applog(LOG_ERR, "Found unknown ztex board"); |
||||
ret = CHECK_IS_NOT_ZTEX; |
||||
goto done; |
||||
} |
||||
|
||||
// testing for dummy firmware
|
||||
if (buf[8] != 0) { |
||||
ret = CHECK_OK; |
||||
goto done; |
||||
} |
||||
|
||||
applog(LOG_ERR, "Found dummy firmware, trying to send mining firmware"); |
||||
|
||||
char productString[32]; |
||||
|
||||
cnt = libztex_get_string_descriptor_ascii(hndl, desc.iProduct, (unsigned char*)productString, sizeof(productString)); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to read device productString with err %d", cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
applog(LOG_ERR, "productString: %s", productString); |
||||
|
||||
unsigned char productID2 = buf[7]; |
||||
char *firmware = NULL; |
||||
|
||||
if (strcmp("USB-FPGA Module 1.15d (default)", productString) == 0 && productID2 == 13) |
||||
{ |
||||
firmware = "ztex_ufm1_15d4.bin"; |
||||
} |
||||
else if (strcmp("USB-FPGA Module 1.15x (default)", productString) == 0 && productID2 == 13) |
||||
{ |
||||
firmware = "ztex_ufm1_15d4.bin"; |
||||
} |
||||
else if (strcmp("USB-FPGA Module 1.15y (default)", productString) == 0 && productID2 == 15) |
||||
{ |
||||
firmware = "ztex_ufm1_15y1.bin"; |
||||
} |
||||
|
||||
if (firmware == NULL) |
||||
{ |
||||
applog(LOG_ERR, "could not figure out which firmware to use"); |
||||
goto done; |
||||
} |
||||
|
||||
applog(LOG_ERR, "Mining firmware filename: %s", firmware); |
||||
|
||||
fp = open_bitstream("ztex", firmware); |
||||
if (!fp) { |
||||
applog(LOG_ERR, "failed to open firmware file '%s'", firmware); |
||||
goto done; |
||||
} |
||||
|
||||
if (0 != fseek(fp, 0, SEEK_END)) { |
||||
applog(LOG_ERR, "Ztex firmware fseek: %s", strerror(errno)); |
||||
goto done; |
||||
} |
||||
|
||||
length = ftell(fp); |
||||
rewind(fp); |
||||
fw_buf = malloc(length); |
||||
if (!fw_buf) { |
||||
applog(LOG_ERR, "%s: Can not allocate memory: %s", __func__, strerror(errno)); |
||||
goto done; |
||||
} |
||||
|
||||
got_bytes = fread(fw_buf, 1, length, fp); |
||||
fclose(fp); |
||||
fp = NULL; |
||||
|
||||
if (got_bytes < length) { |
||||
applog(LOG_ERR, "%s: Incomplete firmware read: %d/%d", __func__, (int)got_bytes, (int)length); |
||||
goto done; |
||||
} |
||||
|
||||
// in buf[] is still the identifier of the dummy firmware
|
||||
// use it to compare it with the new firmware
|
||||
char *rv = memmem(fw_buf, got_bytes, buf, 8); |
||||
if (rv == NULL) |
||||
{ |
||||
applog(LOG_ERR, "%s: found firmware is not ZTEX", __func__); |
||||
goto done; |
||||
} |
||||
|
||||
// check for dummy firmware
|
||||
if (rv[8] == 0) |
||||
{ |
||||
applog(LOG_ERR, "%s: found a ZTEX dummy firmware", __func__); |
||||
goto done; |
||||
} |
||||
|
||||
if (libztex_firmwareReset(hndl, true)) |
||||
goto done; |
||||
|
||||
for (i = 0; i < length; i+= 256) { |
||||
// firmware wants data in small chunks like 256 bytes
|
||||
int numbytes = (length - i) < 256 ? (length - i) : 256; |
||||
int k = libusb_control_transfer(hndl, 0x40, 0xA0, i, 0, fw_buf + i, numbytes, 1000); |
||||
if (k < numbytes) |
||||
{ |
||||
applog(LOG_ERR, "Ztex device: Failed to write firmware at %d with err: %d", i, k); |
||||
goto done; |
||||
} |
||||
} |
||||
|
||||
if (libztex_firmwareReset(hndl, false)) |
||||
goto done; |
||||
|
||||
applog(LOG_ERR, "Ztex device: succesfully wrote firmware"); |
||||
ret = CHECK_RESCAN; |
||||
|
||||
done: |
||||
if (fp) |
||||
fclose(fp); |
||||
if (hndl) |
||||
libusb_close(hndl); |
||||
return ret; |
||||
} |
||||
|
||||
static bool libztex_checkCapability(struct libztex_device *ztex, int i, int j) |
||||
{ |
||||
if (!((i >= 0) && (i <= 5) && (j >= 0) && (j < 8) && |
||||
(((ztex->interfaceCapabilities[i] & 255) & (1 << j)) != 0))) { |
||||
applog(LOG_ERR, "%s: capability missing: %d %d", ztex->repr, i, j); |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
static char libztex_detectBitstreamBitOrder(const unsigned char *buf, int size) |
||||
{ |
||||
int i; |
||||
|
||||
for (i = 0; i < size - 4; i++) { |
||||
if (((buf[i] & 255) == 0xaa) && ((buf[i + 1] & 255) == 0x99) && ((buf[i + 2] & 255) == 0x55) && ((buf[i + 3] & 255) == 0x66)) |
||||
return 1; |
||||
if (((buf[i] & 255) == 0x55) && ((buf[i + 1] & 255) == 0x99) && ((buf[i + 2] & 255) == 0xaa) && ((buf[i + 3] & 255) == 0x66)) |
||||
return 0; |
||||
} |
||||
applog(LOG_WARNING, "Unable to determine bitstream bit order: no signature found"); |
||||
return 0; |
||||
} |
||||
|
||||
static void libztex_swapBits(unsigned char *buf, int size) |
||||
{ |
||||
unsigned char c; |
||||
int i; |
||||
|
||||
for (i = 0; i < size; i++) { |
||||
c = buf[i]; |
||||
buf[i] = ((c & 128) >> 7) | |
||||
((c & 64) >> 5) | |
||||
((c & 32) >> 3) | |
||||
((c & 16) >> 1) | |
||||
((c & 8) << 1) | |
||||
((c & 4) << 3) | |
||||
((c & 2) << 5) | |
||||
((c & 1) << 7); |
||||
} |
||||
} |
||||
|
||||
static int libztex_getFpgaState(struct libztex_device *ztex, struct libztex_fpgastate *state) |
||||
{ |
||||
unsigned char buf[9]; |
||||
int cnt; |
||||
|
||||
if (!libztex_checkCapability(ztex, CAPABILITY_FPGA)) |
||||
return -1; |
||||
cnt = libusb_control_transfer(ztex->hndl, 0xc0, 0x30, 0, 0, buf, 9, 1000); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "%s: Failed getFpgaState with err %d", ztex->repr, cnt); |
||||
return cnt; |
||||
} |
||||
state->fpgaConfigured = (buf[0] == 0); |
||||
state->fpgaChecksum = buf[1] & 0xff; |
||||
state->fpgaBytes = ((buf[5] & 0xff) << 24) | ((buf[4] & 0xff) << 16) | ((buf[3] & 0xff) << 8) | (buf[2] & 0xff); |
||||
state->fpgaInitB = buf[6] & 0xff; |
||||
state->fpgaFlashResult = buf[7]; |
||||
state->fpgaFlashBitSwap = (buf[8] != 0); |
||||
return 0; |
||||
} |
||||
|
||||
static int libztex_configureFpgaHS(struct libztex_device *ztex, const char* firmware, bool force, char bs) |
||||
{ |
||||
struct libztex_fpgastate state; |
||||
const int transactionBytes = 65536; |
||||
unsigned char buf[transactionBytes], settings[2]; |
||||
int tries, cnt, err; |
||||
FILE *fp; |
||||
|
||||
if (!libztex_checkCapability(ztex, CAPABILITY_HS_FPGA)) |
||||
return -1; |
||||
libztex_getFpgaState(ztex, &state); |
||||
if (!force && state.fpgaConfigured) { |
||||
applog(LOG_INFO, "Bitstream already configured"); |
||||
return 0; |
||||
} |
||||
cnt = libusb_control_transfer(ztex->hndl, 0xc0, 0x33, 0, 0, settings, 2, 1000); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "%s: Failed getHSFpgaSettings with err %d", ztex->repr, cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
err = libusb_claim_interface(ztex->hndl, settings[1]); |
||||
if (err != LIBUSB_SUCCESS) { |
||||
applog(LOG_ERR, "%s: failed to claim interface for hs transfer", ztex->repr); |
||||
return -4; |
||||
} |
||||
|
||||
for (tries = 3; tries > 0; tries--) { |
||||
fp = open_bitstream("ztex", firmware); |
||||
if (!fp) { |
||||
applog(LOG_ERR, "%s: failed to read bitstream '%s'", ztex->repr, firmware); |
||||
libusb_release_interface(ztex->hndl, settings[1]); |
||||
return -2; |
||||
} |
||||
|
||||
libusb_control_transfer(ztex->hndl, 0x40, 0x34, 0, 0, NULL, 0, 1000); |
||||
// 0x34 - initHSFPGAConfiguration
|
||||
|
||||
do |
||||
{ |
||||
int length = fread(buf,1,transactionBytes,fp); |
||||
|
||||
if (bs != 0 && bs != 1) |
||||
bs = libztex_detectBitstreamBitOrder(buf, length); |
||||
if (bs == 1) |
||||
libztex_swapBits(buf, length); |
||||
|
||||
err = libusb_bulk_transfer(ztex->hndl, settings[0], buf, length, &cnt, 1000); |
||||
if (cnt != length) |
||||
applog(LOG_ERR, "%s: cnt != length", ztex->repr); |
||||
if (err != 0) |
||||
applog(LOG_ERR, "%s: Failed send hs fpga data", ztex->repr); |
||||
} |
||||
while (!feof(fp)); |
||||
|
||||
libusb_control_transfer(ztex->hndl, 0x40, 0x35, 0, 0, NULL, 0, 1000); |
||||
// 0x35 - finishHSFPGAConfiguration
|
||||
if (cnt >= 0) |
||||
tries = 0; |
||||
|
||||
fclose(fp); |
||||
|
||||
libztex_getFpgaState(ztex, &state); |
||||
if (!state.fpgaConfigured) { |
||||
applog(LOG_ERR, "%s: HS FPGA configuration failed: DONE pin does not go high", ztex->repr); |
||||
libusb_release_interface(ztex->hndl, settings[1]); |
||||
return -3; |
||||
} |
||||
} |
||||
|
||||
libusb_release_interface(ztex->hndl, settings[1]); |
||||
|
||||
cgsleep_ms(200); |
||||
applog(LOG_INFO, "%s: HS FPGA configuration done", ztex->repr); |
||||
return 0; |
||||
} |
||||
|
||||
static int libztex_configureFpgaLS(struct libztex_device *ztex, const char* firmware, bool force, char bs) |
||||
{ |
||||
struct libztex_fpgastate state; |
||||
const int transactionBytes = 2048; |
||||
unsigned char buf[transactionBytes]; |
||||
int tries, cnt; |
||||
FILE *fp; |
||||
|
||||
if (!libztex_checkCapability(ztex, CAPABILITY_FPGA)) |
||||
return -1; |
||||
|
||||
libztex_getFpgaState(ztex, &state); |
||||
if (!force && state.fpgaConfigured) { |
||||
applog(LOG_DEBUG, "Bitstream already configured"); |
||||
return 0; |
||||
} |
||||
|
||||
for (tries = 10; tries > 0; tries--) { |
||||
fp = open_bitstream("ztex", firmware); |
||||
if (!fp) { |
||||
applog(LOG_ERR, "%s: failed to read bitstream '%s'", ztex->repr, firmware); |
||||
return -2; |
||||
} |
||||
|
||||
//* Reset fpga
|
||||
cnt = libztex_resetFpga(ztex); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "%s: Failed reset fpga with err %d", ztex->repr, cnt); |
||||
continue; |
||||
} |
||||
|
||||
do |
||||
{ |
||||
int length = fread(buf, 1, transactionBytes, fp); |
||||
|
||||
if (bs != 0 && bs != 1) |
||||
bs = libztex_detectBitstreamBitOrder(buf, length); |
||||
if (bs == 1) |
||||
libztex_swapBits(buf, length); |
||||
cnt = libusb_control_transfer(ztex->hndl, 0x40, 0x32, 0, 0, buf, length, 5000); |
||||
if (cnt != length) |
||||
{ |
||||
applog(LOG_ERR, "%s: Failed send ls fpga data", ztex->repr); |
||||
break; |
||||
} |
||||
} |
||||
while (!feof(fp)); |
||||
|
||||
if (cnt > 0) |
||||
tries = 0; |
||||
|
||||
fclose(fp); |
||||
} |
||||
|
||||
libztex_getFpgaState(ztex, &state); |
||||
if (!state.fpgaConfigured) { |
||||
applog(LOG_ERR, "%s: LS FPGA configuration failed: DONE pin does not go high", ztex->repr); |
||||
return -3; |
||||
} |
||||
|
||||
cgsleep_ms(200); |
||||
applog(LOG_INFO, "%s: FPGA configuration done", ztex->repr); |
||||
return 0; |
||||
} |
||||
|
||||
int libztex_configureFpga(struct libztex_device *ztex) |
||||
{ |
||||
char buf[256]; |
||||
int rv; |
||||
|
||||
strcpy(buf, ztex->bitFileName); |
||||
strcat(buf, ".bit"); |
||||
rv = libztex_configureFpgaHS(ztex, buf, true, 2); |
||||
if (rv != 0) |
||||
rv = libztex_configureFpgaLS(ztex, buf, true, 2); |
||||
return rv; |
||||
} |
||||
|
||||
int libztex_numberOfFpgas(struct libztex_device *ztex) |
||||
{ |
||||
int cnt; |
||||
unsigned char buf[3]; |
||||
|
||||
if (ztex->numberOfFpgas < 0) { |
||||
if (libztex_checkCapability(ztex, CAPABILITY_MULTI_FPGA)) { |
||||
cnt = libusb_control_transfer(ztex->hndl, 0xc0, 0x50, 0, 0, buf, 3, 1000); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "%s: Failed getMultiFpgaInfo with err %d", ztex->repr, cnt); |
||||
return cnt; |
||||
} |
||||
ztex->numberOfFpgas = buf[0] + 1; |
||||
ztex->selectedFpga = -1;//buf[1];
|
||||
ztex->parallelConfigSupport = (buf[2] == 1); |
||||
} else { |
||||
ztex->numberOfFpgas = 1; |
||||
ztex->selectedFpga = -1;//0;
|
||||
ztex->parallelConfigSupport = false; |
||||
} |
||||
} |
||||
return ztex->numberOfFpgas; |
||||
} |
||||
|
||||
int libztex_selectFpga(struct libztex_device *ztex) |
||||
{ |
||||
int cnt, fpgacnt = libztex_numberOfFpgas(ztex->root); |
||||
int16_t number = ztex->fpgaNum; |
||||
|
||||
if (number < 0 || number >= fpgacnt) { |
||||
applog(LOG_WARNING, "%s: Trying to select wrong fpga (%d in %d)", ztex->repr, number, fpgacnt); |
||||
return 1; |
||||
} |
||||
if (ztex->root->selectedFpga != number && libztex_checkCapability(ztex->root, CAPABILITY_MULTI_FPGA)) { |
||||
cnt = libusb_control_transfer(ztex->root->hndl, 0x40, 0x51, (uint16_t)number, 0, NULL, 0, 500); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to set fpga with err %d", cnt); |
||||
ztex->root->selectedFpga = -1; |
||||
return cnt; |
||||
} |
||||
ztex->root->selectedFpga = number; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
int libztex_setFreq(struct libztex_device *ztex, uint16_t freq) |
||||
{ |
||||
int cnt; |
||||
uint16_t oldfreq = ztex->freqM; |
||||
|
||||
if (freq > ztex->freqMaxM) |
||||
freq = ztex->freqMaxM; |
||||
|
||||
cnt = libusb_control_transfer(ztex->hndl, 0x40, 0x83, freq, 0, NULL, 0, 500); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to set frequency with err %d", cnt); |
||||
return cnt; |
||||
} |
||||
ztex->freqM = freq; |
||||
if (oldfreq > ztex->freqMaxM) |
||||
applog(LOG_WARNING, "%s: Frequency set to %0.1f MHz", |
||||
ztex->repr, ztex->freqM1 * (ztex->freqM + 1)); |
||||
else |
||||
applog(LOG_WARNING, "%s: Frequency change from %0.1f to %0.1f MHz", |
||||
ztex->repr, ztex->freqM1 * (oldfreq + 1), ztex->freqM1 * (ztex->freqM + 1)); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int libztex_resetFpga(struct libztex_device *ztex) |
||||
{ |
||||
return libusb_control_transfer(ztex->hndl, 0x40, 0x31, 0, 0, NULL, 0, 1000); |
||||
} |
||||
|
||||
int libztex_suspend(struct libztex_device *ztex) |
||||
{ |
||||
if (ztex->suspendSupported) { |
||||
return libusb_control_transfer(ztex->hndl, 0x40, 0x84, 0, 0, NULL, 0, 1000); |
||||
} else { |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
int libztex_prepare_device(struct libusb_device *dev, struct libztex_device** ztex) |
||||
{ |
||||
struct libztex_device *newdev = *ztex; |
||||
int i, cnt, err; |
||||
unsigned char buf[64]; |
||||
|
||||
err = libusb_open(dev, &newdev->hndl); |
||||
if (err != LIBUSB_SUCCESS) { |
||||
applog(LOG_ERR, "%s: Can not open ZTEX device: %d", __func__, err); |
||||
return CHECK_ERROR; |
||||
} |
||||
|
||||
err = libusb_get_device_descriptor(dev, &newdev->descriptor); |
||||
if (unlikely(err != 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to open read descriptor with error %d", err); |
||||
return CHECK_ERROR; |
||||
} |
||||
|
||||
cnt = libztex_get_string_descriptor_ascii(newdev->hndl, newdev->descriptor.iSerialNumber, newdev->snString, sizeof(newdev->snString)); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to read device snString with err %d", cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
cnt = libusb_control_transfer(newdev->hndl, 0xc0, 0x22, 0, 0, buf, 40, 500); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to read ztex descriptor with err %d", cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
if (buf[0] != 40 || buf[1] != 1 || buf[2] != 'Z' || buf[3] != 'T' || buf[4] != 'E' || buf[5] != 'X') { |
||||
applog(LOG_ERR, "Ztex check device: Error reading ztex descriptor"); |
||||
return 2; |
||||
} |
||||
|
||||
newdev->productId[0] = buf[6]; |
||||
newdev->productId[1] = buf[7]; |
||||
newdev->productId[2] = buf[8]; |
||||
newdev->productId[3] = buf[9]; |
||||
newdev->fwVersion = buf[10]; |
||||
newdev->interfaceVersion = buf[11]; |
||||
newdev->interfaceCapabilities[0] = buf[12]; |
||||
newdev->interfaceCapabilities[1] = buf[13]; |
||||
newdev->interfaceCapabilities[2] = buf[14]; |
||||
newdev->interfaceCapabilities[3] = buf[15]; |
||||
newdev->interfaceCapabilities[4] = buf[16]; |
||||
newdev->interfaceCapabilities[5] = buf[17]; |
||||
newdev->moduleReserved[0] = buf[18]; |
||||
newdev->moduleReserved[1] = buf[19]; |
||||
newdev->moduleReserved[2] = buf[20]; |
||||
newdev->moduleReserved[3] = buf[21]; |
||||
newdev->moduleReserved[4] = buf[22]; |
||||
newdev->moduleReserved[5] = buf[23]; |
||||
newdev->moduleReserved[6] = buf[24]; |
||||
newdev->moduleReserved[7] = buf[25]; |
||||
newdev->moduleReserved[8] = buf[26]; |
||||
newdev->moduleReserved[9] = buf[27]; |
||||
newdev->moduleReserved[10] = buf[28]; |
||||
newdev->moduleReserved[11] = buf[29]; |
||||
|
||||
cnt = libusb_control_transfer(newdev->hndl, 0xc0, 0x82, 0, 0, buf, 64, 500); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex check device: Failed to read ztex descriptor with err %d", cnt); |
||||
return cnt; |
||||
} |
||||
|
||||
if (unlikely(buf[0] != 5)) { |
||||
if (unlikely(buf[0] != 2 && buf[0] != 4)) { |
||||
applog(LOG_ERR, "Invalid BTCMiner descriptor version. Firmware must be updated (%d).", buf[0]); |
||||
return 3; |
||||
} |
||||
applog(LOG_WARNING, "Firmware out of date (%d).", buf[0]); |
||||
} |
||||
|
||||
i = buf[0] > 4? 11: (buf[0] > 2? 10: 8); |
||||
|
||||
while (cnt < 64 && buf[cnt] != 0) |
||||
cnt++; |
||||
if (cnt < i + 1) { |
||||
applog(LOG_ERR, "Invalid bitstream file name ."); |
||||
return 4; |
||||
} |
||||
|
||||
newdev->bitFileName = malloc(sizeof(char) * (cnt + 1)); |
||||
memcpy(newdev->bitFileName, &buf[i], cnt); |
||||
newdev->bitFileName[cnt] = 0; |
||||
|
||||
newdev->numNonces = buf[1] + 1; |
||||
newdev->offsNonces = ((buf[2] & 255) | ((buf[3] & 255) << 8)) - 10000; |
||||
newdev->freqM1 = ((buf[4] & 255) | ((buf[5] & 255) << 8) ) * 0.01; |
||||
newdev->freqMaxM = (buf[7] & 255); |
||||
newdev->freqM = (buf[6] & 255); |
||||
newdev->freqMDefault = newdev->freqM; |
||||
newdev->suspendSupported = (buf[0] == 5); |
||||
newdev->hashesPerClock = buf[0] > 2? (((buf[8] & 255) | ((buf[9] & 255) << 8)) + 1) / 128.0: 1.0; |
||||
newdev->extraSolutions = buf[0] > 4? buf[10]: 0; |
||||
|
||||
applog(LOG_DEBUG, "PID: %d numNonces: %d offsNonces: %d freqM1: %f freqMaxM: %d freqM: %d suspendSupported: %s hashesPerClock: %f extraSolutions: %d", |
||||
buf[0], newdev->numNonces, newdev->offsNonces, newdev->freqM1, newdev->freqMaxM, newdev->freqM, newdev->suspendSupported ? "T": "F", |
||||
newdev->hashesPerClock, newdev->extraSolutions); |
||||
|
||||
if (buf[0] < 4) { |
||||
if (strncmp(newdev->bitFileName, "ztex_ufm1_15b", 13) != 0) |
||||
newdev->hashesPerClock = 0.5; |
||||
applog(LOG_WARNING, "HASHES_PER_CLOCK not defined, assuming %0.2f", newdev->hashesPerClock); |
||||
} |
||||
|
||||
for (cnt=0; cnt < 255; cnt++) { |
||||
newdev->errorCount[cnt] = 0; |
||||
newdev->errorWeight[cnt] = 0; |
||||
newdev->errorRate[cnt] = 0; |
||||
newdev->maxErrorRate[cnt] = 0; |
||||
} |
||||
|
||||
// fake that the last round found something valid
|
||||
newdev->nonceCheckValid = 1; |
||||
|
||||
newdev->usbbus = libusb_get_bus_number(dev); |
||||
newdev->usbaddress = libusb_get_device_address(dev); |
||||
sprintf(newdev->repr, "ZTEX %s-1", newdev->snString); |
||||
return 0; |
||||
} |
||||
|
||||
void libztex_destroy_device(struct libztex_device* ztex) |
||||
{ |
||||
if (ztex->hndl != NULL) { |
||||
libusb_close(ztex->hndl); |
||||
ztex->hndl = NULL; |
||||
} |
||||
if (ztex->bitFileName != NULL) { |
||||
free(ztex->bitFileName); |
||||
ztex->bitFileName = NULL; |
||||
} |
||||
free(ztex); |
||||
} |
||||
|
||||
int libztex_scanDevices(struct libztex_dev_list*** devs_p) |
||||
{ |
||||
int usbdevices[LIBZTEX_MAX_DESCRIPTORS]; |
||||
struct libztex_dev_list **devs = NULL; |
||||
struct libztex_device *ztex = NULL; |
||||
int found, max_found = 0, pos = 0, err, rescan, ret = 0; |
||||
libusb_device **list = NULL; |
||||
ssize_t cnt, i; |
||||
|
||||
do { |
||||
cnt = libusb_get_device_list(NULL, &list); |
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "Ztex scan devices: Failed to list usb devices with err %d", (int)cnt); |
||||
goto done; |
||||
} |
||||
|
||||
for (found = rescan = i = 0; i < cnt; i++) { |
||||
err = libztex_checkDevice(list[i]); |
||||
switch (err) { |
||||
case CHECK_ERROR: |
||||
applog(LOG_ERR, "Ztex: Can not check device: %d", err); |
||||
continue; |
||||
case CHECK_IS_NOT_ZTEX: |
||||
continue; |
||||
case CHECK_OK: |
||||
// Got one!
|
||||
usbdevices[found++] = i; |
||||
break; |
||||
case CHECK_RESCAN: |
||||
rescan = 1; |
||||
found++; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if (found < max_found) |
||||
rescan = 1; |
||||
else if (found > max_found) |
||||
max_found = found; |
||||
|
||||
if (rescan) |
||||
libusb_free_device_list(list, 1); |
||||
} while (rescan); |
||||
|
||||
if (0 == found) |
||||
goto done; |
||||
|
||||
devs = malloc(sizeof(struct libztex_dev_list *) * found); |
||||
if (devs == NULL) { |
||||
applog(LOG_ERR, "Ztex scan devices: Failed to allocate memory"); |
||||
goto done; |
||||
} |
||||
|
||||
for (i = 0; i < found; i++) { |
||||
if (!ztex) { |
||||
ztex = malloc(sizeof(*ztex)); |
||||
if (!ztex) { |
||||
applog(LOG_ERR, "%s: Can not allocate memory for device struct: %s", __func__, strerror(errno)); |
||||
goto done; |
||||
} |
||||
} |
||||
|
||||
ztex->bitFileName = NULL; |
||||
ztex->numberOfFpgas = -1; |
||||
|
||||
err = libztex_prepare_device(list[usbdevices[i]], &ztex); |
||||
if (unlikely(err != 0)) { |
||||
applog(LOG_ERR, "prepare device: %d", err); |
||||
libztex_destroy_device(ztex); |
||||
ztex = NULL; |
||||
continue; |
||||
} |
||||
|
||||
devs[pos] = malloc(sizeof(struct libztex_dev_list)); |
||||
if (NULL == devs[pos]) { |
||||
applog(LOG_ERR, "%s: Can not allocate memory for device: %s", __func__, strerror(errno)); |
||||
libztex_destroy_device(ztex); |
||||
ztex = NULL; |
||||
continue; |
||||
} |
||||
|
||||
devs[pos]->dev = ztex; |
||||
ztex = NULL; |
||||
devs[pos]->next = NULL; |
||||
if (pos > 0) |
||||
devs[pos - 1]->next = devs[pos]; |
||||
pos++; |
||||
} |
||||
|
||||
ret = pos; |
||||
|
||||
done: |
||||
if (ret > 0) |
||||
*devs_p = devs; |
||||
else if (devs) |
||||
free(devs); |
||||
if (list) |
||||
libusb_free_device_list(list, 1); |
||||
return ret; |
||||
} |
||||
|
||||
int libztex_sendHashData(struct libztex_device *ztex, unsigned char *sendbuf) |
||||
{ |
||||
int cnt = 0, ret, len; |
||||
|
||||
if (ztex == NULL || ztex->hndl == NULL) |
||||
return 0; |
||||
ret = 44; len = 0; |
||||
while (ret > 0) { |
||||
cnt = libusb_control_transfer(ztex->hndl, 0x40, 0x80, 0, 0, sendbuf + len, ret, 1000); |
||||
if (cnt >= 0) { |
||||
ret -= cnt; |
||||
len += cnt; |
||||
} else |
||||
break; |
||||
} |
||||
if (unlikely(cnt < 0)) |
||||
applog(LOG_ERR, "%s: Failed sendHashData with err %d", ztex->repr, cnt); |
||||
|
||||
return cnt; |
||||
} |
||||
|
||||
int libztex_readHashData(struct libztex_device *ztex, struct libztex_hash_data nonces[]) |
||||
{ |
||||
int bufsize = 12 + ztex->extraSolutions * 4; |
||||
int cnt = 0, i, j, ret, len; |
||||
unsigned char *rbuf; |
||||
|
||||
if (ztex->hndl == NULL) |
||||
return 0; |
||||
|
||||
rbuf = malloc(sizeof(unsigned char) * (ztex->numNonces * bufsize)); |
||||
if (rbuf == NULL) { |
||||
applog(LOG_ERR, "%s: Failed to allocate memory for reading nonces", ztex->repr); |
||||
return 0; |
||||
} |
||||
ret = bufsize * ztex->numNonces; len = 0; |
||||
while (ret > 0) { |
||||
cnt = libusb_control_transfer(ztex->hndl, 0xc0, 0x81, 0, 0, rbuf + len, ret, 1000); |
||||
if (cnt >= 0) { |
||||
ret -= cnt; |
||||
len += cnt; |
||||
} else |
||||
break; |
||||
} |
||||
|
||||
if (unlikely(cnt < 0)) { |
||||
applog(LOG_ERR, "%s: Failed readHashData with err %d", ztex->repr, cnt); |
||||
free(rbuf); |
||||
return cnt; |
||||
} |
||||
|
||||
for (i=0; i<ztex->numNonces; i++) { |
||||
memcpy((char*)&nonces[i].goldenNonce[0], &rbuf[i*bufsize], 4); |
||||
nonces[i].goldenNonce[0] -= ztex->offsNonces; |
||||
//applog(LOG_DEBUG, "W %d:0 %0.8x", i, nonces[i].goldenNonce[0]);
|
||||
|
||||
memcpy((char*)&nonces[i].nonce, &rbuf[(i*bufsize)+4], 4); |
||||
memcpy((char*)&nonces[i].hash7, &rbuf[(i*bufsize)+8], 4); |
||||
|
||||
nonces[i].nonce = htole32(nonces[i].nonce); |
||||
nonces[i].hash7 = htole32(nonces[i].hash7); |
||||
|
||||
nonces[i].nonce -= ztex->offsNonces; |
||||
|
||||
for (j=0; j<ztex->extraSolutions; j++) { |
||||
memcpy((char*)&nonces[i].goldenNonce[j+1], &rbuf[(i*bufsize)+12+(j*4)], 4); |
||||
nonces[i].goldenNonce[j+1] = htole32(nonces[i].goldenNonce[j+1]); |
||||
nonces[i].goldenNonce[j+1] -= ztex->offsNonces; |
||||
//applog(LOG_DEBUG, "W %d:%d %0.8x", i, j+1, nonces[i].goldenNonce[j+1]);
|
||||
} |
||||
} |
||||
|
||||
free(rbuf); |
||||
return cnt; |
||||
} |
||||
|
||||
void libztex_freeDevList(struct libztex_dev_list **devs) |
||||
{ |
||||
bool done = false; |
||||
ssize_t cnt = 0; |
||||
|
||||
while (!done) { |
||||
if (devs[cnt]->next == NULL) |
||||
done = true; |
||||
free(devs[cnt++]); |
||||
} |
||||
free(devs); |
||||
} |
||||
|
||||
@ -1,108 +0,0 @@
@@ -1,108 +0,0 @@
|
||||
/**
|
||||
* libztex.h - headers for Ztex 1.15x fpga board support library |
||||
* |
||||
* Copyright (c) 2012 nelisky.btc@gmail.com |
||||
* |
||||
* This work is based upon the Java SDK provided by ztex which is |
||||
* Copyright (C) 2009-2011 ZTEX GmbH. |
||||
* http://www.ztex.de
|
||||
* |
||||
* This program is free software; you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License version 2 as |
||||
* published by the Free Software Foundation. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, but |
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||||
* General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, see http://www.gnu.org/licenses/.
|
||||
**/ |
||||
#ifndef __LIBZTEX_H__ |
||||
#define __LIBZTEX_H__ |
||||
|
||||
#include <libusb.h> |
||||
|
||||
#define LIBZTEX_MAX_DESCRIPTORS 512 |
||||
#define LIBZTEX_SNSTRING_LEN 10 |
||||
|
||||
#define LIBZTEX_IDVENDOR 0x221A |
||||
#define LIBZTEX_IDPRODUCT 0x0100 |
||||
|
||||
#define LIBZTEX_MAXMAXERRORRATE 0.05 |
||||
#define LIBZTEX_ERRORHYSTERESIS 0.1 |
||||
#define LIBZTEX_OVERHEATTHRESHOLD 0.4 |
||||
|
||||
struct libztex_fpgastate { |
||||
bool fpgaConfigured; |
||||
unsigned char fpgaChecksum; |
||||
uint16_t fpgaBytes; |
||||
unsigned char fpgaInitB; |
||||
unsigned char fpgaFlashResult; |
||||
bool fpgaFlashBitSwap; |
||||
}; |
||||
|
||||
struct libztex_device { |
||||
pthread_mutex_t mutex; |
||||
struct libztex_device *root; |
||||
int16_t fpgaNum; |
||||
struct libusb_device_descriptor descriptor; |
||||
libusb_device_handle *hndl; |
||||
unsigned char usbbus; |
||||
unsigned char usbaddress; |
||||
unsigned char snString[LIBZTEX_SNSTRING_LEN+1]; |
||||
unsigned char productId[4]; |
||||
unsigned char fwVersion; |
||||
unsigned char interfaceVersion; |
||||
unsigned char interfaceCapabilities[6]; |
||||
unsigned char moduleReserved[12]; |
||||
uint8_t numNonces; |
||||
uint16_t offsNonces; |
||||
double freqM1; |
||||
uint8_t freqM; |
||||
uint8_t freqMaxM; |
||||
uint8_t freqMDefault; |
||||
char* bitFileName; |
||||
bool suspendSupported; |
||||
double hashesPerClock; |
||||
uint8_t extraSolutions; |
||||
|
||||
double errorCount[256]; |
||||
double errorWeight[256]; |
||||
double errorRate[256]; |
||||
double maxErrorRate[256]; |
||||
|
||||
int16_t nonceCheckValid; |
||||
|
||||
int16_t numberOfFpgas; |
||||
int selectedFpga; |
||||
bool parallelConfigSupport; |
||||
|
||||
char repr[20]; |
||||
}; |
||||
|
||||
struct libztex_dev_list { |
||||
struct libztex_device *dev; |
||||
struct libztex_dev_list *next; |
||||
}; |
||||
|
||||
struct libztex_hash_data { |
||||
uint32_t goldenNonce[2]; |
||||
uint32_t nonce; |
||||
uint32_t hash7; |
||||
}; |
||||
|
||||
extern int libztex_scanDevices (struct libztex_dev_list ***devs); |
||||
extern void libztex_freeDevList (struct libztex_dev_list **devs); |
||||
extern int libztex_prepare_device (struct libusb_device *dev, struct libztex_device** ztex); |
||||
extern void libztex_destroy_device (struct libztex_device* ztex); |
||||
extern int libztex_configureFpga (struct libztex_device *dev); |
||||
extern int libztex_setFreq (struct libztex_device *ztex, uint16_t freq); |
||||
extern int libztex_sendHashData (struct libztex_device *ztex, unsigned char *sendbuf); |
||||
extern int libztex_readHashData (struct libztex_device *ztex, struct libztex_hash_data nonces[]); |
||||
extern int libztex_resetFpga (struct libztex_device *ztex); |
||||
extern int libztex_selectFpga(struct libztex_device *ztex); |
||||
extern int libztex_numberOfFpgas(struct libztex_device *ztex); |
||||
|
||||
#endif /* __LIBZTEX_H__ */ |
||||
@ -1,5 +0,0 @@
@@ -1,5 +0,0 @@
|
||||
- verify setting cgpu.status=DEAD does in fact stop the thread |
||||
- allow configuring bitstream directory |
||||
- HS fpga config |
||||
- allow configuring LIBZTEX_OVERHEATTHRESHOLD |
||||
- hotplug support? |
||||
Loading…
Reference in new issue