static void search_for_extra_nonce(struct thr_info *thr, struct work *work,
struct hf_candidate_nonce *n)
{
uint32_t nonce = n->nonce;
int i;
/* No function to test with ntime offsets yet */
if (n->ntime & HF_NTIME_MASK)
return;
for (i = 0; i < 128; i++, nonce++) {
/* We could break out of this early if nonce wraps or if we
* find one correct nonce since the chance of more is extremely
* low but this function will be hit so infrequently we may as
* well test the entire range with the least code. */
if (test_nonce(work, nonce))
submit_tested_work(thr, work);
}
}
static void gridseed_test_btc_nonce(struct cgpu_info *gridseed, GRIDSEED_INFO *info,
struct thr_info *thr, unsigned char *data)
{
struct work *work;
uint32_t nonce;
int workid, index, i;
bool valid = false;
bool nowork = false;
memcpy(&workid, data+8, 4);
memcpy(&nonce, data+4, 4);
nonce = htole32(nonce);
mutex_lock(&info->qlock);
nowork = (info->soft_queue_len <= 0);
for(i=0; i<info->soft_queue_len; i++) {
struct work *dupwork;
work = info->workqueue[i];
if (work->devflag == false)
continue;
if (work->id > workid)
break;
dupwork = copy_work(work);
if (dupwork == NULL)
continue;
if (test_nonce(dupwork, nonce)) {
submit_tested_work(thr, dupwork);
index = i;
valid = true;
free_work(dupwork);
break;
} else
free_work(dupwork);
}
if (valid)
__gridseed_purge_work_queue(gridseed, info, index);
mutex_unlock(&info->qlock);
if (!valid && !nowork)
inc_hw_errors(thr);
return;
}
static int64_t ztex_scanhash(struct thr_info *thr, struct work *work,
__maybe_unused int64_t max_nonce)
{
struct cgpu_info *cgpu = thr->cgpu;
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, cgpu->proc_id);
i = libztex_sendHashData(ztex, sendbuf);
if (i < 0) {
// Something wrong happened in send
applog(LOG_ERR, "%"PRIpreprv": Failed to send hash data with err %d, retrying", cgpu->proc_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, "%"PRIpreprv": Failed to send hash data with err %d, giving up", cgpu->proc_repr, i);
ztex_releaseFpga(ztex);
return -1;
}
}
ztex_releaseFpga(ztex);
applog(LOG_DEBUG, "%"PRIpreprv": sent hashdata", cgpu->proc_repr);
lastnonce = calloc(1, sizeof(uint32_t)*ztex->numNonces);
if (lastnonce == NULL) {
applog(LOG_ERR, "%"PRIpreprv": failed to allocate lastnonce[%d]", cgpu->proc_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, "%"PRIpreprv": failed to allocate backlog[%d]", cgpu->proc_repr, backlog_max);
free(lastnonce);
return -1;
}
overflow = false;
int count = 0;
applog(LOG_DEBUG, "%"PRIpreprv": entering poll loop", cgpu->proc_repr);
while (!(overflow || thr->work_restart)) {
count++;
if (!restart_wait(thr, 250))
{
applog(LOG_DEBUG, "%"PRIpreprv": New work detected", cgpu->proc_repr);
break;
}
ztex_selectFpga(ztex, cgpu->proc_id);
i = libztex_readHashData(ztex, &hdata[0]);
if (i < 0) {
// Something wrong happened in read
applog(LOG_ERR, "%"PRIpreprv": Failed to read hash data with err %d, retrying", cgpu->proc_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, "%"PRIpreprv": Failed to read hash data with err %d, giving up", cgpu->proc_repr, i);
free(lastnonce);
free(backlog);
ztex_releaseFpga(ztex);
return -1;
}
}
ztex_releaseFpga(ztex);
if (thr->work_restart) {
applog(LOG_DEBUG, "%"PRIpreprv": New work detected", cgpu->proc_repr);
break;
}
dclk_gotNonces(&ztex->dclk);
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, "%"PRIpreprv": overflow nonce=%08x lastnonce=%08x", cgpu->proc_repr, nonce, lastnonce[i]);
overflow = true;
} else
lastnonce[i] = nonce;
if (!ztex_checkNonce(cgpu, work, &hdata[i])) {
// do not count errors in the first 500ms after sendHashData (2x250 wait time)
if (count > 2)
dclk_errorCount(&ztex->dclk, 1.0 / ztex->numNonces);
inc_hw_errors_only(thr);
}
for (j=0; j<=ztex->extraSolutions; j++) {
nonce = hdata[i].goldenNonce[j];
if (nonce == ztex->offsNonces) {
continue;
}
found = false;
for (k = 0; k < backlog_max; k++) {
if (backlog[k] == nonce) {
found = true;
break;
}
}
if (!found) {
backlog[backlog_p++] = nonce;
if (backlog_p >= backlog_max)
backlog_p = 0;
work->blk.nonce = 0xffffffff;
if (!j || test_nonce(work, nonce, false))
submit_nonce(thr, work, nonce);
applog(LOG_DEBUG, "%"PRIpreprv": submitted %08x (from N%dE%d)", cgpu->proc_repr, nonce, i, j);
}
}
}
}
dclk_preUpdate(&ztex->dclk);
if (!ztex_updateFreq(thr)) {
// Something really serious happened, so mark this thread as dead!
free(lastnonce);
free(backlog);
return -1;
}
applog(LOG_DEBUG, "%"PRIpreprv": exit %1.8X", cgpu->proc_repr, noncecnt);
work->blk.nonce = 0xffffffff;
free(lastnonce);
free(backlog);
return noncecnt;
}