GOSTSec
/
sgminer
mirror of https://github.com/GOSTSec/sgminer
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

icarus->USB v0.1 incomplete - missing initialise()

nfactor-troky
Kano 12 years ago
parent
dad308701b
commit
9f46aa9012
1 changed files with 178 additions and 183 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 361
      driver-icarus.c

361
driver-icarus.c
Unescape View File

@ -1,7 +1,6 @@
/* /*
* Copyright 2012 Luke Dashjr * Copyright 2012-2013 Andrew Smith
* Copyright 2012 Xiangfu <xiangfu@openmobilefree.com> * Copyright 2012 Xiangfu <xiangfu@openmobilefree.com>
* Copyright 2012 Andrew Smith
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
@ -29,30 +28,25 @@
* nonce range is completely calculated. * nonce range is completely calculated.
*/ */
#include "config.h"
#include "miner.h"
#include <float.h>
#include <limits.h> #include <limits.h>
#include <pthread.h> #include <pthread.h>
#include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <strings.h>
#include <sys/time.h> #include <sys/time.h>
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h> #include <unistd.h>
#ifndef WIN32
#include <termios.h> #include "config.h"
#include <sys/stat.h>
#include <fcntl.h> #ifdef WIN32
#ifndef O_CLOEXEC #include <windows.h>
#define O_CLOEXEC 0
#endif
#else
#include <windows.h>
#include <io.h>
#endif #endif
#include "elist.h" #include "compat.h"
#include "fpgautils.h" #include "miner.h"
#include "usbutils.h"
// The serial I/O speed - Linux uses a define 'B115200' in bits/termios.h // The serial I/O speed - Linux uses a define 'B115200' in bits/termios.h
#define ICARUS_IO_SPEED 115200 #define ICARUS_IO_SPEED 115200
@ -67,41 +61,51 @@
#define ASSERT1(condition) __maybe_unused static char sizeof_uint32_t_must_be_4[(condition)?1:-1] #define ASSERT1(condition) __maybe_unused static char sizeof_uint32_t_must_be_4[(condition)?1:-1]
ASSERT1(sizeof(uint32_t) == 4); ASSERT1(sizeof(uint32_t) == 4);
#define ICARUS_READ_TIME(baud) ((double)ICARUS_READ_SIZE * (double)8.0 / (double)(baud)) // TODO: USB? Different calculation? - see usbstats to work it out e.g. 1/2 of normal send time
// or even use that number? 1/2
// #define ICARUS_READ_TIME(baud) ((double)ICARUS_READ_SIZE * (double)8.0 / (double)(baud))
// maybe 1ms?
#define ICARUS_READ_TIME(baud) (0.001)
// Fraction of a second, USB timeout is measured in // USB ms timeout to wait
// i.e. 10 means 1/10 of a second #define ICARUS_WAIT_TIMEOUT 100
#define TIME_FACTOR 10
// It's 10 per second, thus value = 10/TIME_FACTOR =
#define ICARUS_READ_FAULT_DECISECONDS 1
// In timing mode: Default starting value until an estimate can be obtained // In timing mode: Default starting value until an estimate can be obtained
// 5 seconds allows for up to a ~840MH/s device // 5000 ms allows for up to a ~840MH/s device
#define ICARUS_READ_COUNT_TIMING (5 * TIME_FACTOR) #define ICARUS_READ_COUNT_TIMING 5000
#define ICARUS_READ_COUNT_MIN ICARUS_WAIT_TIMEOUT
#define SECTOMS(s) ((int)((s) * 1000))
// How many ms below the expected completion time to abort work
// extra in case the last read is delayed
#define ICARUS_READ_REDUCE ((int)(ICARUS_WAIT_TIMEOUT * 1.5))
// For a standard Icarus REV3 (to 5 places) // For a standard Icarus REV3 (to 5 places)
// Since this rounds up a the last digit - it is a slight overestimate // Since this rounds up a the last digit - it is a slight overestimate
// Thus the hash rate will be a VERY slight underestimate // Thus the hash rate will be a VERY slight underestimate
// (by a lot less than the displayed accuracy) // (by a lot less than the displayed accuracy)
// Minor inaccuracy of these numbers doesn't affect the work done,
// only the displayed MH/s
#define ICARUS_REV3_HASH_TIME 0.0000000026316 #define ICARUS_REV3_HASH_TIME 0.0000000026316
#define LANCELOT_HASH_TIME 0.0000000025000
#define ASICMINERUSB_HASH_TIME 0.0000000029761
#define NANOSEC 1000000000.0 #define NANOSEC 1000000000.0
// Icarus Rev3 doesn't send a completion message when it finishes // Icarus Rev3 doesn't send a completion message when it finishes
// the full nonce range, so to avoid being idle we must abort the // the full nonce range, so to avoid being idle we must abort the
// work (by starting a new work) shortly before it finishes // work (by starting a new work item) shortly before it finishes
// //
// Thus we need to estimate 2 things: // Thus we need to estimate 2 things:
// 1) How many hashes were done if the work was aborted // 1) How many hashes were done if the work was aborted
// 2) How high can the timeout be before the Icarus is idle, // 2) How high can the timeout be before the Icarus is idle,
// to minimise the number of work started // to minimise the number of work items started
// We set 2) to 'the calculated estimate' - 1 // We set 2) to 'the calculated estimate' - ICARUS_READ_REDUCE
// to ensure the estimate ends before idle // to ensure the estimate ends before idle
// //
// The simple calculation used is: // The simple calculation used is:
// Tn = Total time in seconds to calculate n hashes // Tn = Total time in seconds to calculate n hashes
// Hs = seconds per hash // Hs = seconds per hash
// Xn = number of hashes // Xn = number of hashes
// W = code overhead per work // W = code/usb overhead per work
// //
// Rough but reasonable estimate: // Rough but reasonable estimate:
// Tn = Hs * Xn + W (of the form y = mx + b) // Tn = Hs * Xn + W (of the form y = mx + b)
@ -123,7 +127,7 @@ ASSERT1(sizeof(uint32_t) == 4);
#define HISTORY_SEC 60 #define HISTORY_SEC 60
// Minimum how many points a single ICARUS_HISTORY should have // Minimum how many points a single ICARUS_HISTORY should have
#define MIN_DATA_COUNT 5 #define MIN_DATA_COUNT 5
// The value above used is doubled each history until it exceeds: // The value MIN_DATA_COUNT used is doubled each history until it exceeds:
#define MAX_MIN_DATA_COUNT 100 #define MAX_MIN_DATA_COUNT 100
static struct timeval history_sec = { HISTORY_SEC, 0 }; static struct timeval history_sec = { HISTORY_SEC, 0 };
@ -163,7 +167,8 @@ struct ICARUS_INFO {
// seconds per Hash // seconds per Hash
double Hs; double Hs;
int read_count; // ms til we abort
int read_time;
enum timing_mode timing_mode; enum timing_mode timing_mode;
bool do_icarus_timing; bool do_icarus_timing;
@ -195,7 +200,8 @@ static struct ICARUS_INFO **icarus_info;
// //
// Code increments this each time we start to look at a device // Code increments this each time we start to look at a device
// However, this means that if other devices are checked by // However, this means that if other devices are checked by
// the Icarus code (e.g. BFL) they will count in the option offset // the Icarus code (e.g. Avalon only as at 20130517)
// they will count in the option offset
// //
// This, however, is deterministic so that's OK // This, however, is deterministic so that's OK
// //
@ -203,13 +209,21 @@ static struct ICARUS_INFO **icarus_info;
// that would be random since an Icarus may fail and thus we'd // that would be random since an Icarus may fail and thus we'd
// not be able to predict the option order // not be able to predict the option order
// //
// This also assumes that serial_detect() checks them sequentially // Devices are checked in the order libusb finds them which is ?
// and in the order specified on the command line
// //
static int option_offset = -1; static int option_offset = -1;
struct device_drv icarus_drv; struct device_drv icarus_drv;
static void icarus_initialise(struct cgpu_info *icarus, int baud)
{
if (icarus->usbinfo.nodev)
return;
if (baud) {
}
}
static void rev(unsigned char *s, size_t l) static void rev(unsigned char *s, size_t l)
{ {
size_t i, j; size_t i, j;
@ -222,81 +236,63 @@ static void rev(unsigned char *s, size_t l)
} }
} }
#define icarus_open2(devpath, baud, purge) serial_open(devpath, baud, ICARUS_READ_FAULT_DECISECONDS, purge) #define ICA_NONCE_ERROR -1
#define icarus_open(devpath, baud) icarus_open2(devpath, baud, false) #define ICA_NONCE_OK 0
#define ICA_NONCE_RESTART 1
#define ICA_NONCE_TIMEOUT 2
#define ICA_GETS_ERROR -1 static int icarus_get_nonce(struct cgpu_info *icarus, unsigned char *buf, struct timeval *tv_start, struct timeval *tv_finish, struct thr_info *thr, int read_time)
#define ICA_GETS_OK 0
#define ICA_GETS_RESTART 1
#define ICA_GETS_TIMEOUT 2
static int icarus_gets(unsigned char *buf, int fd, struct timeval *tv_finish, struct thr_info *thr, int read_count)
{ {
ssize_t ret = 0; struct timeval read_start, read_finish;
int err, amt;
int rc = 0; int rc = 0;
int read_amount = ICARUS_READ_SIZE; int read_amount = ICARUS_READ_SIZE;
bool first = true; bool first = true;
// Read reply 1 byte at a time to get earliest tv_finish cgtime(tv_start);
while (true) { while (true) {
ret = read(fd, buf, 1); cgtime(&read_start);
if (ret < 0) err = usb_read_timeout(icarus, (char *)buf, read_amount, &amt, ICARUS_WAIT_TIMEOUT, C_GETRESULTS);
return ICA_GETS_ERROR; cgtime(&read_finish);
if (err < 0 && err != LIBUSB_ERROR_TIMEOUT) {
applog(LOG_ERR, "%s%i: Comms error", icarus->drv->name, icarus->device_id);
dev_error(icarus, REASON_DEV_COMMS_ERROR);
return ICA_NONCE_ERROR;
}
if (first) if (first)
cgtime(tv_finish); copy_time(tv_finish, &read_finish);
if (ret >= read_amount) // TODO: test if there is more data? to read a 2nd nonce?
return ICA_GETS_OK; if (amt >= ICARUS_READ_SIZE)
return ICA_NONCE_OK;
if (ret > 0) { if (amt > 0) {
buf += ret; buf += amt;
read_amount -= ret; read_amount -= amt;
first = false; first = false;
continue; continue;
} }
rc++; rc += SECTOMS(tdiff(&read_finish, &read_start));
if (rc >= read_count) { if (rc >= read_time) {
if (opt_debug) { if (opt_debug) {
applog(LOG_DEBUG, applog(LOG_DEBUG,
"Icarus Read: No data in %.2f seconds", "Icarus Read: No data in %d ms", rc);
(float)rc/(float)TIME_FACTOR);
} }
return ICA_GETS_TIMEOUT; return ICA_NONCE_TIMEOUT;
} }
if (thr && thr->work_restart) { if (thr && thr->work_restart) {
if (opt_debug) { if (opt_debug) {
applog(LOG_DEBUG, applog(LOG_DEBUG,
"Icarus Read: Work restart at %.2f seconds", "Icarus Read: Work restart at %d ms", rc);
(float)(rc)/(float)TIME_FACTOR);
} }
return ICA_GETS_RESTART; return ICA_NONCE_RESTART;
} }
} }
} }
static int icarus_write(int fd, const void *buf, size_t bufLen)
{
size_t ret;
ret = write(fd, buf, bufLen);
if (unlikely(ret != bufLen))
return 1;
return 0;
}
#define icarus_close(fd) close(fd)
static void do_icarus_close(struct thr_info *thr)
{
struct cgpu_info *icarus = thr->cgpu;
icarus_close(icarus->device_fd);
icarus->device_fd = -1;
}
static const char *timing_mode_str(enum timing_mode timing_mode) static const char *timing_mode_str(enum timing_mode timing_mode)
{ {
switch(timing_mode) { switch(timing_mode) {
@ -346,17 +342,17 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
} }
info->Hs = 0; info->Hs = 0;
info->read_count = 0; info->read_time = 0;
if (strcasecmp(buf, MODE_SHORT_STR) == 0) { if (strcasecmp(buf, MODE_SHORT_STR) == 0) {
info->Hs = ICARUS_REV3_HASH_TIME; info->Hs = ICARUS_REV3_HASH_TIME;
info->read_count = ICARUS_READ_COUNT_TIMING; info->read_time = ICARUS_READ_COUNT_TIMING;
info->timing_mode = MODE_SHORT; info->timing_mode = MODE_SHORT;
info->do_icarus_timing = true; info->do_icarus_timing = true;
} else if (strcasecmp(buf, MODE_LONG_STR) == 0) { } else if (strcasecmp(buf, MODE_LONG_STR) == 0) {
info->Hs = ICARUS_REV3_HASH_TIME; info->Hs = ICARUS_REV3_HASH_TIME;
info->read_count = ICARUS_READ_COUNT_TIMING; info->read_time = ICARUS_READ_COUNT_TIMING;
info->timing_mode = MODE_LONG; info->timing_mode = MODE_LONG;
info->do_icarus_timing = true; info->do_icarus_timing = true;
@ -365,13 +361,13 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
info->fullnonce = info->Hs * (((double)0xffffffff) + 1); info->fullnonce = info->Hs * (((double)0xffffffff) + 1);
if ((eq = strchr(buf, '=')) != NULL) if ((eq = strchr(buf, '=')) != NULL)
info->read_count = atoi(eq+1); info->read_time = atoi(eq+1) * ICARUS_WAIT_TIMEOUT;
if (info->read_count < 1) if (info->read_time < ICARUS_READ_COUNT_MIN)
info->read_count = (int)(info->fullnonce * TIME_FACTOR) - 1; info->read_time = SECTOMS(info->fullnonce) - ICARUS_READ_REDUCE;
if (unlikely(info->read_count < 1)) if (unlikely(info->read_time < ICARUS_READ_COUNT_MIN))
info->read_count = 1; info->read_time = ICARUS_READ_COUNT_MIN;
info->timing_mode = MODE_VALUE; info->timing_mode = MODE_VALUE;
info->do_icarus_timing = false; info->do_icarus_timing = false;
@ -382,10 +378,13 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
info->fullnonce = info->Hs * (((double)0xffffffff) + 1); info->fullnonce = info->Hs * (((double)0xffffffff) + 1);
if ((eq = strchr(buf, '=')) != NULL) if ((eq = strchr(buf, '=')) != NULL)
info->read_count = atoi(eq+1); info->read_time = atoi(eq+1) * ICARUS_WAIT_TIMEOUT;
if (info->read_time < ICARUS_READ_COUNT_MIN)
info->read_time = SECTOMS(info->fullnonce) - ICARUS_READ_REDUCE;
if (info->read_count < 1) if (unlikely(info->read_time < ICARUS_READ_COUNT_MIN))
info->read_count = (int)(info->fullnonce * TIME_FACTOR) - 1; info->read_time = ICARUS_READ_COUNT_MIN;
info->timing_mode = MODE_DEFAULT; info->timing_mode = MODE_DEFAULT;
info->do_icarus_timing = false; info->do_icarus_timing = false;
@ -393,8 +392,8 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
info->min_data_count = MIN_DATA_COUNT; info->min_data_count = MIN_DATA_COUNT;
applog(LOG_DEBUG, "Icarus: Init: %d mode=%s read_count=%d Hs=%e", applog(LOG_DEBUG, "Icarus: Init: %d mode=%s read_time=%dms Hs=%e",
icarus->device_id, timing_mode_str(info->timing_mode), info->read_count, info->Hs); icarus->device_id, timing_mode_str(info->timing_mode), info->read_time, info->Hs);
} }
static uint32_t mask(int work_division) static uint32_t mask(int work_division)
@ -508,13 +507,12 @@ static void get_options(int this_option_offset, int *baud, int *work_division, i
} }
} }
static bool icarus_detect_one(const char *devpath) static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices *found)
{ {
int this_option_offset = ++option_offset; int this_option_offset = ++option_offset;
char devpath[20];
struct ICARUS_INFO *info; struct ICARUS_INFO *info;
struct timeval tv_start, tv_finish; struct timeval tv_start, tv_finish;
int fd;
// Block 171874 nonce = (0xa2870100) = 0x000187a2 // Block 171874 nonce = (0xa2870100) = 0x000187a2
// N.B. golden_ob MUST take less time to calculate // N.B. golden_ob MUST take less time to calculate
@ -528,30 +526,52 @@ static bool icarus_detect_one(const char *devpath)
const char golden_nonce[] = "000187a2"; const char golden_nonce[] = "000187a2";
const uint32_t golden_nonce_val = 0x000187a2; const uint32_t golden_nonce_val = 0x000187a2;
unsigned char ob_bin[64], nonce_bin[ICARUS_READ_SIZE]; unsigned char ob_bin[64], nonce_bin[ICARUS_READ_SIZE];
char *nonce_hex; char *nonce_hex;
int baud, work_division, fpga_count; int baud, work_division, fpga_count;
struct cgpu_info *icarus;
int ret, err, amount, tries;
get_options(this_option_offset, &baud, &work_division, &fpga_count); get_options(this_option_offset, &baud, &work_division, &fpga_count);
applog(LOG_DEBUG, "Icarus Detect: Attempting to open %s", devpath); icarus = calloc(1, sizeof(struct cgpu_info));
if (unlikely(!icarus))
quit(1, "Failed to calloc icarus in icarus_detect_one");
icarus->drv = &icarus_drv;
icarus->deven = DEV_ENABLED;
icarus->threads = 1;
fd = icarus_open2(devpath, baud, true); if (!usb_init(icarus, dev, found))
if (unlikely(fd == -1)) { goto shin;
applog(LOG_ERR, "Icarus Detect: Failed to open %s", devpath);
return false; // TODO: set options based on ident if options not supplied
} // add a flag to say options were set by parameters
sprintf(devpath, "%d:%d",
(int)(icarus->usbinfo.bus_number),
(int)(icarus->usbinfo.device_address));
icarus->device_path = strdup(devpath);
hex2bin(ob_bin, golden_ob, sizeof(ob_bin)); hex2bin(ob_bin, golden_ob, sizeof(ob_bin));
icarus_write(fd, ob_bin, sizeof(ob_bin));
cgtime(&tv_start);
memset(nonce_bin, 0, sizeof(nonce_bin)); tries = 0;
icarus_gets(nonce_bin, fd, &tv_finish, NULL, 1); while (++tries) {
icarus_initialise(icarus, baud);
err = usb_write(icarus, (char *)ob_bin, sizeof(ob_bin), &amount, C_SENDTESTWORK);
icarus_close(fd); if (err == LIBUSB_SUCCESS && amount == sizeof(ob_bin))
break;
if (tries > 2)
goto unshin;
}
memset(nonce_bin, 0, sizeof(nonce_bin));
ret = icarus_get_nonce(icarus, nonce_bin, &tv_start, &tv_finish, NULL, 1);
if (ret != ICA_NONCE_OK)
goto unshin;
nonce_hex = bin2hex(nonce_bin, sizeof(nonce_bin)); nonce_hex = bin2hex(nonce_bin, sizeof(nonce_bin));
if (strncmp(nonce_hex, golden_nonce, 8)) { if (strncmp(nonce_hex, golden_nonce, 8)) {
@ -560,7 +580,7 @@ static bool icarus_detect_one(const char *devpath)
"Test failed at %s: get %s, should: %s", "Test failed at %s: get %s, should: %s",
devpath, nonce_hex, golden_nonce); devpath, nonce_hex, golden_nonce);
free(nonce_hex); free(nonce_hex);
return false; goto unshin;
} }
applog(LOG_DEBUG, applog(LOG_DEBUG,
"Icarus Detect: " "Icarus Detect: "
@ -569,14 +589,14 @@ static bool icarus_detect_one(const char *devpath)
free(nonce_hex); free(nonce_hex);
/* We have a real Icarus! */ /* We have a real Icarus! */
struct cgpu_info *icarus; if (!add_cgpu(icarus))
icarus = calloc(1, sizeof(struct cgpu_info)); goto unshin;
icarus->drv = &icarus_drv;
icarus->device_path = strdup(devpath); update_usb_stats(icarus);
icarus->device_fd = -1;
icarus->threads = 1;
add_cgpu(icarus);
icarus_info = realloc(icarus_info, sizeof(struct ICARUS_INFO *) * (total_devices + 1)); icarus_info = realloc(icarus_info, sizeof(struct ICARUS_INFO *) * (total_devices + 1));
if (unlikely(!icarus_info))
quit(1, "Failed to realloc ICARUS_INFO");
applog(LOG_INFO, "Found Icarus at %s, mark as %d", applog(LOG_INFO, "Found Icarus at %s, mark as %d",
devpath, icarus->device_id); devpath, icarus->device_id);
@ -605,11 +625,23 @@ static bool icarus_detect_one(const char *devpath)
set_timing_mode(this_option_offset, icarus); set_timing_mode(this_option_offset, icarus);
return true; return true;
unshin:
usb_uninit(icarus);
free(icarus->device_path);
shin:
free(icarus);
return false;
} }
static void icarus_detect() static void icarus_detect()
{ {
serial_detect(&icarus_drv, icarus_detect_one); usb_detect(&icarus_drv, icarus_detect_one);
} }
static bool icarus_prepare(struct thr_info *thr) static bool icarus_prepare(struct thr_info *thr)
@ -618,18 +650,6 @@ static bool icarus_prepare(struct thr_info *thr)
struct timeval now; struct timeval now;
icarus->device_fd = -1;
int fd = icarus_open(icarus->device_path, icarus_info[icarus->device_id]->baud);
if (unlikely(-1 == fd)) {
applog(LOG_ERR, "Failed to open Icarus on %s",
icarus->device_path);
return false;
}
icarus->device_fd = fd;
applog(LOG_INFO, "Opened Icarus on %s", icarus->device_path);
cgtime(&now); cgtime(&now);
get_datestamp(icarus->init, &now); get_datestamp(icarus->init, &now);
@ -639,9 +659,8 @@ static bool icarus_prepare(struct thr_info *thr)
static int64_t icarus_scanhash(struct thr_info *thr, struct work *work, static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
__maybe_unused int64_t max_nonce) __maybe_unused int64_t max_nonce)
{ {
struct cgpu_info *icarus; struct cgpu_info *icarus = thr->cgpu;
int fd; int ret, err, amount;
int ret;
struct ICARUS_INFO *info; struct ICARUS_INFO *info;
@ -658,43 +677,32 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
struct ICARUS_HISTORY *history0, *history; struct ICARUS_HISTORY *history0, *history;
int count; int count;
double Hs, W, fullnonce; double Hs, W, fullnonce;
int read_count; int read_time;
int64_t estimate_hashes; int64_t estimate_hashes;
uint32_t values; uint32_t values;
int64_t hash_count_range; int64_t hash_count_range;
elapsed.tv_sec = elapsed.tv_usec = 0; // Device is gone
if (icarus->usbinfo.nodev)
icarus = thr->cgpu; return -1;
if (icarus->device_fd == -1)
if (!icarus_prepare(thr)) {
applog(LOG_ERR, "%s%i: Comms error", icarus->drv->name, icarus->device_id);
dev_error(icarus, REASON_DEV_COMMS_ERROR);
// fail the device if the reopen attempt fails
return -1;
}
fd = icarus->device_fd; info = icarus_info[icarus->device_id];
elapsed.tv_sec = elapsed.tv_usec = 0;
memset(ob_bin, 0, sizeof(ob_bin)); memset(ob_bin, 0, sizeof(ob_bin));
memcpy(ob_bin, work->midstate, 32); memcpy(ob_bin, work->midstate, 32);
memcpy(ob_bin + 52, work->data + 64, 12); memcpy(ob_bin + 52, work->data + 64, 12);
rev(ob_bin, 32); rev(ob_bin, 32);
rev(ob_bin + 52, 12); rev(ob_bin + 52, 12);
#ifndef WIN32
tcflush(fd, TCOFLUSH); err = usb_write(icarus, (char *)ob_bin, sizeof(ob_bin), &amount, C_SENDWORK);
#endif if (err < 0 || amount != sizeof(ob_bin)) {
ret = icarus_write(fd, ob_bin, sizeof(ob_bin));
if (ret) {
do_icarus_close(thr);
applog(LOG_ERR, "%s%i: Comms error", icarus->drv->name, icarus->device_id); applog(LOG_ERR, "%s%i: Comms error", icarus->drv->name, icarus->device_id);
dev_error(icarus, REASON_DEV_COMMS_ERROR); dev_error(icarus, REASON_DEV_COMMS_ERROR);
return 0; /* This should never happen */ icarus_initialise(icarus, info->baud);
return 0;
} }
cgtime(&tv_start);
if (opt_debug) { if (opt_debug) {
ob_hex = bin2hex(ob_bin, sizeof(ob_bin)); ob_hex = bin2hex(ob_bin, sizeof(ob_bin));
applog(LOG_DEBUG, "Icarus %d sent: %s", applog(LOG_DEBUG, "Icarus %d sent: %s",
@ -704,19 +712,14 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
/* Icarus will return 4 bytes (ICARUS_READ_SIZE) nonces or nothing */ /* Icarus will return 4 bytes (ICARUS_READ_SIZE) nonces or nothing */
memset(nonce_bin, 0, sizeof(nonce_bin)); memset(nonce_bin, 0, sizeof(nonce_bin));
info = icarus_info[icarus->device_id]; ret = icarus_get_nonce(icarus, nonce_bin, &tv_start, &tv_finish, thr, info->read_time);
ret = icarus_gets(nonce_bin, fd, &tv_finish, thr, info->read_count); if (ret == ICA_NONCE_ERROR)
if (ret == ICA_GETS_ERROR) {
do_icarus_close(thr);
applog(LOG_ERR, "%s%i: Comms error", icarus->drv->name, icarus->device_id);
dev_error(icarus, REASON_DEV_COMMS_ERROR);
return 0; return 0;
}
work->blk.nonce = 0xffffffff; work->blk.nonce = 0xffffffff;
// aborted before becoming idle, get new work // aborted before becoming idle, get new work
if (ret == ICA_GETS_TIMEOUT || ret == ICA_GETS_RESTART) { if (ret == ICA_NONCE_TIMEOUT || ret == ICA_NONCE_RESTART) {
timersub(&tv_finish, &tv_start, &elapsed); timersub(&tv_finish, &tv_start, &elapsed);
// ONLY up to just when it aborted // ONLY up to just when it aborted
@ -739,19 +742,11 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
} }
memcpy((char *)&nonce, nonce_bin, sizeof(nonce_bin)); memcpy((char *)&nonce, nonce_bin, sizeof(nonce_bin));
nonce = htobe32(nonce);
#if !defined (__BIG_ENDIAN__) && !defined(MIPSEB)
nonce = swab32(nonce);
#endif
curr_hw_errors = icarus->hw_errors; curr_hw_errors = icarus->hw_errors;
submit_nonce(thr, work, nonce); submit_nonce(thr, work, nonce);
was_hw_error = (curr_hw_errors > icarus->hw_errors); was_hw_error = (curr_hw_errors > icarus->hw_errors);
// Force a USB close/reopen on any hw error
if (was_hw_error)
do_icarus_close(thr);
hash_count = (nonce & info->nonce_mask); hash_count = (nonce & info->nonce_mask);
hash_count++; hash_count++;
hash_count *= info->fpga_count; hash_count *= info->fpga_count;
@ -804,7 +799,7 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
memset(history0, 0, sizeof(struct ICARUS_HISTORY)); memset(history0, 0, sizeof(struct ICARUS_HISTORY));
// We just completed a history data set // We just completed a history data set
// So now recalc read_count based on the whole history thus we will // So now recalc read_time based on the whole history thus we will
// initially get more accurate until it completes INFO_HISTORY // initially get more accurate until it completes INFO_HISTORY
// total data sets // total data sets
count = 0; count = 0;
@ -837,10 +832,10 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
memset(history0, 0, sizeof(struct ICARUS_HISTORY)); memset(history0, 0, sizeof(struct ICARUS_HISTORY));
fullnonce = W + Hs * (((double)0xffffffff) + 1); fullnonce = W + Hs * (((double)0xffffffff) + 1);
read_count = (int)(fullnonce * TIME_FACTOR) - 1; read_time = SECTOMS(fullnonce) - ICARUS_READ_REDUCE;
info->Hs = Hs; info->Hs = Hs;
info->read_count = read_count; info->read_time = read_time;
info->fullnonce = fullnonce; info->fullnonce = fullnonce;
info->count = count; info->count = count;
@ -853,9 +848,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
else if (info->timing_mode == MODE_SHORT) else if (info->timing_mode == MODE_SHORT)
info->do_icarus_timing = false; info->do_icarus_timing = false;
// applog(LOG_WARNING, "Icarus %d Re-estimate: read_count=%d fullnonce=%fs history count=%d Hs=%e W=%e values=%d hash range=0x%08lx min data count=%u", icarus->device_id, read_count, fullnonce, count, Hs, W, values, hash_count_range, info->min_data_count); // applog(LOG_WARNING, "Icarus %d Re-estimate: read_time=%d fullnonce=%fs history count=%d Hs=%e W=%e values=%d hash range=0x%08lx min data count=%u", icarus->device_id, read_time, fullnonce, count, Hs, W, values, hash_count_range, info->min_data_count);
applog(LOG_WARNING, "Icarus %d Re-estimate: Hs=%e W=%e read_count=%d fullnonce=%.3fs", applog(LOG_WARNING, "Icarus %d Re-estimate: Hs=%e W=%e read_time=%dms fullnonce=%.3fs",
icarus->device_id, Hs, W, read_count, fullnonce); icarus->device_id, Hs, W, read_time, fullnonce);
} }
info->history_count++; info->history_count++;
cgtime(&tv_history_finish); cgtime(&tv_history_finish);
@ -876,7 +871,7 @@ static struct api_data *icarus_api_stats(struct cgpu_info *cgpu)
// care since hashing performance is way more important than // care since hashing performance is way more important than
// locking access to displaying API debug 'stats' // locking access to displaying API debug 'stats'
// If locking becomes an issue for any of them, use copy_data=true also // If locking becomes an issue for any of them, use copy_data=true also
root = api_add_int(root, "read_count", &(info->read_count), false); root = api_add_int(root, "read_time", &(info->read_time), false);
root = api_add_double(root, "fullnonce", &(info->fullnonce), false); root = api_add_double(root, "fullnonce", &(info->fullnonce), false);
root = api_add_int(root, "count", &(info->count), false); root = api_add_int(root, "count", &(info->count), false);
root = api_add_hs(root, "Hs", &(info->Hs), false); root = api_add_hs(root, "Hs", &(info->Hs), false);
@ -896,9 +891,9 @@ static struct api_data *icarus_api_stats(struct cgpu_info *cgpu)
return root; return root;
} }
static void icarus_shutdown(struct thr_info *thr) static void icarus_shutdown(__maybe_unused struct thr_info *thr)
{ {
do_icarus_close(thr); // TODO: ?
} }
struct device_drv icarus_drv = { struct device_drv icarus_drv = {

Write Preview
Loading…
Cancel
Save