|
|
|
@ -1,7 +1,7 @@ |
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* 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 |
|
|
|
* Copyright 2013 Con Kolivas <kernel@kolivas.org> |
|
|
|
* |
|
|
|
* |
|
|
|
* 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 +29,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 +62,53 @@ |
|
|
|
#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 |
|
|
|
|
|
|
|
// TODO: What is it?
|
|
|
|
|
|
|
|
#define CAIRNSMORE1_HASH_TIME 0.0000000026316 |
|
|
|
#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 +130,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 +170,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; |
|
|
|
@ -188,14 +196,12 @@ struct ICARUS_INFO { |
|
|
|
|
|
|
|
|
|
|
|
#define END_CONDITION 0x0000ffff |
|
|
|
#define END_CONDITION 0x0000ffff |
|
|
|
|
|
|
|
|
|
|
|
// One for each possible device
|
|
|
|
|
|
|
|
static struct ICARUS_INFO **icarus_info; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Looking for options in --icarus-timing and --icarus-options:
|
|
|
|
// Looking for options in --icarus-timing and --icarus-options:
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// 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,173 @@ 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; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
#define ICA_BUFSIZ (0x200) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void transfer_read(struct cgpu_info *icarus, uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, char *buf, int bufsiz, int *amount, enum usb_cmds cmd) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
int err; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
err = usb_transfer_read(icarus, request_type, bRequest, wValue, wIndex, buf, bufsiz, amount, cmd); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
applog(LOG_DEBUG, "%s: cgid %d %s got err %d", |
|
|
|
|
|
|
|
icarus->drv->name, icarus->cgminer_id, |
|
|
|
|
|
|
|
usb_cmdname(cmd), err); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void _transfer(struct cgpu_info *icarus, uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, uint32_t *data, int siz, enum usb_cmds cmd) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
int err; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
err = usb_transfer_data(icarus, request_type, bRequest, wValue, wIndex, data, siz, cmd); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
applog(LOG_DEBUG, "%s: cgid %d %s got err %d", |
|
|
|
|
|
|
|
icarus->drv->name, icarus->cgminer_id, |
|
|
|
|
|
|
|
usb_cmdname(cmd), err); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define transfer(icarus, request_type, bRequest, wValue, wIndex, cmd) \ |
|
|
|
|
|
|
|
_transfer(icarus, request_type, bRequest, wValue, wIndex, NULL, 0, cmd) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void icarus_initialise(struct cgpu_info *icarus, int baud) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
uint16_t wValue, wIndex; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
switch (icarus->usbdev->ident) { |
|
|
|
|
|
|
|
case IDENT_BLT: |
|
|
|
|
|
|
|
case IDENT_LLT: |
|
|
|
|
|
|
|
case IDENT_CMR1: |
|
|
|
|
|
|
|
case IDENT_CMR2: |
|
|
|
|
|
|
|
// Latency
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_LATENCY, FTDI_VALUE_LATENCY, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_LATENCY); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Reset
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_RESET, FTDI_VALUE_RESET, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_RESET); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Set data control
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_DATA, FTDI_VALUE_DATA_BLT, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_SETDATA); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// default to BLT/LLT 115200
|
|
|
|
|
|
|
|
wValue = FTDI_VALUE_BAUD_BLT; |
|
|
|
|
|
|
|
wIndex = FTDI_INDEX_BAUD_BLT; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbdev->ident == IDENT_CMR1 || |
|
|
|
|
|
|
|
icarus->usbdev->ident == IDENT_CMR2) { |
|
|
|
|
|
|
|
switch (baud) { |
|
|
|
|
|
|
|
case 115200: |
|
|
|
|
|
|
|
wValue = FTDI_VALUE_BAUD_CMR_115; |
|
|
|
|
|
|
|
wIndex = FTDI_INDEX_BAUD_CMR_115; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
case 57600: |
|
|
|
|
|
|
|
wValue = FTDI_VALUE_BAUD_CMR_57; |
|
|
|
|
|
|
|
wIndex = FTDI_INDEX_BAUD_CMR_57; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
default: |
|
|
|
|
|
|
|
quit(1, "icarus_intialise() invalid baud (%d) for Cairnsmore1", baud); |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Set the baud
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, wValue, |
|
|
|
|
|
|
|
(wIndex & 0xff00) | icarus->usbdev->found->interface, |
|
|
|
|
|
|
|
C_SETBAUD); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Set Modem Control
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM, FTDI_VALUE_MODEM, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_SETMODEM); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Set Flow Control
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW, FTDI_VALUE_FLOW, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_SETFLOW); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Clear any sent data
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_RESET, FTDI_VALUE_PURGE_TX, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_PURGETX); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Clear any received data
|
|
|
|
|
|
|
|
transfer(icarus, FTDI_TYPE_OUT, FTDI_REQUEST_RESET, FTDI_VALUE_PURGE_RX, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_PURGERX); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
case IDENT_ICA: |
|
|
|
|
|
|
|
// Set Data Control
|
|
|
|
|
|
|
|
transfer(icarus, PL2303_CTRL_OUT, PL2303_REQUEST_CTRL, PL2303_VALUE_CTRL, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_SETDATA); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Set Line Control
|
|
|
|
|
|
|
|
uint32_t ica_data[2] = { PL2303_VALUE_LINE0, PL2303_VALUE_LINE1 }; |
|
|
|
|
|
|
|
_transfer(icarus, PL2303_CTRL_OUT, PL2303_REQUEST_LINE, PL2303_VALUE_LINE, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, |
|
|
|
|
|
|
|
&ica_data[0], PL2303_VALUE_LINE_SIZE, C_SETLINE); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Vendor
|
|
|
|
|
|
|
|
transfer(icarus, PL2303_VENDOR_OUT, PL2303_REQUEST_VENDOR, PL2303_VALUE_VENDOR, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_VENDOR); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
case IDENT_AMU: |
|
|
|
|
|
|
|
// Set data control
|
|
|
|
|
|
|
|
transfer(icarus, CP210X_TYPE_OUT, CP210X_REQUEST_DATA, CP210X_VALUE_DATA, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, C_SETDATA); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Set the baud
|
|
|
|
|
|
|
|
uint32_t data = CP210X_DATA_BAUD; |
|
|
|
|
|
|
|
_transfer(icarus, CP210X_TYPE_OUT, CP210X_REQUEST_BAUD, 0, |
|
|
|
|
|
|
|
icarus->usbdev->found->interface, |
|
|
|
|
|
|
|
&data, sizeof(data), C_SETBAUD); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
default: |
|
|
|
|
|
|
|
quit(1, "icarus_intialise() called with invalid %s cgid %i ident=%d", |
|
|
|
|
|
|
|
icarus->drv->name, icarus->cgminer_id, |
|
|
|
|
|
|
|
icarus->usbdev->ident); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
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,79 +388,64 @@ 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_GETS_ERROR -1 |
|
|
|
#define ICA_NONCE_TIMEOUT 2 |
|
|
|
#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) |
|
|
|
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) |
|
|
|
{ |
|
|
|
{ |
|
|
|
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); |
|
|
|
if (icarus->usbinfo.nodev) |
|
|
|
if (ret < 0) |
|
|
|
return ICA_NONCE_ERROR; |
|
|
|
return ICA_GETS_ERROR; |
|
|
|
|
|
|
|
|
|
|
|
cgtime(&read_start); |
|
|
|
|
|
|
|
err = usb_read_timeout(icarus, (char *)buf, read_amount, &amt, ICARUS_WAIT_TIMEOUT, C_GETRESULTS); |
|
|
|
|
|
|
|
cgtime(&read_finish); |
|
|
|
|
|
|
|
if (err < 0 && err != LIBUSB_ERROR_TIMEOUT) { |
|
|
|
|
|
|
|
applog(LOG_ERR, "%s%i: Comms error (rerr=%d amt=%d)", |
|
|
|
|
|
|
|
icarus->drv->name, icarus->device_id, err, amt); |
|
|
|
|
|
|
|
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 >= read_amount) |
|
|
|
|
|
|
|
return ICA_NONCE_OK; |
|
|
|
if (ret > 0) { |
|
|
|
|
|
|
|
buf += ret; |
|
|
|
rc += SECTOMS(tdiff(&read_finish, &read_start)); |
|
|
|
read_amount -= ret; |
|
|
|
if (rc >= read_time) { |
|
|
|
first = false; |
|
|
|
if (amt > 0) |
|
|
|
continue; |
|
|
|
applog(LOG_DEBUG, "Icarus Read: Timeout reading for %d ms", rc); |
|
|
|
} |
|
|
|
else |
|
|
|
|
|
|
|
applog(LOG_DEBUG, "Icarus Read: No data for %d ms", rc); |
|
|
|
rc++; |
|
|
|
return ICA_NONCE_TIMEOUT; |
|
|
|
if (rc >= read_count) { |
|
|
|
|
|
|
|
if (opt_debug) { |
|
|
|
|
|
|
|
applog(LOG_DEBUG, |
|
|
|
|
|
|
|
"Icarus Read: No data in %.2f seconds", |
|
|
|
|
|
|
|
(float)rc/(float)TIME_FACTOR); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
return ICA_GETS_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) |
|
|
|
if (amt > 0) { |
|
|
|
|
|
|
|
buf += amt; |
|
|
|
static void do_icarus_close(struct thr_info *thr) |
|
|
|
read_amount -= amt; |
|
|
|
{ |
|
|
|
first = false; |
|
|
|
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) |
|
|
|
@ -315,7 +466,7 @@ static const char *timing_mode_str(enum timing_mode timing_mode) |
|
|
|
|
|
|
|
|
|
|
|
static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus) |
|
|
|
static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct ICARUS_INFO *info = icarus_info[icarus->device_id]; |
|
|
|
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(icarus->device_data); |
|
|
|
double Hs; |
|
|
|
double Hs; |
|
|
|
char buf[BUFSIZ+1]; |
|
|
|
char buf[BUFSIZ+1]; |
|
|
|
char *ptr, *comma, *eq; |
|
|
|
char *ptr, *comma, *eq; |
|
|
|
@ -345,18 +496,37 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus) |
|
|
|
buf[max] = '\0'; |
|
|
|
buf[max] = '\0'; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
info->Hs = 0; |
|
|
|
switch (icarus->usbdev->ident) { |
|
|
|
info->read_count = 0; |
|
|
|
case IDENT_ICA: |
|
|
|
|
|
|
|
info->Hs = ICARUS_REV3_HASH_TIME; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
case IDENT_BLT: |
|
|
|
|
|
|
|
case IDENT_LLT: |
|
|
|
|
|
|
|
info->Hs = LANCELOT_HASH_TIME; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
case IDENT_AMU: |
|
|
|
|
|
|
|
info->Hs = ASICMINERUSB_HASH_TIME; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
// TODO: ?
|
|
|
|
|
|
|
|
case IDENT_CMR1: |
|
|
|
|
|
|
|
case IDENT_CMR2: |
|
|
|
|
|
|
|
info->Hs = CAIRNSMORE1_HASH_TIME; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
default: |
|
|
|
|
|
|
|
quit(1, "Icarus get_options() called with invalid %s ident=%d", |
|
|
|
|
|
|
|
icarus->drv->name, icarus->usbdev->ident); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
info->read_time = 0; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// TODO: allow short=N and long=N
|
|
|
|
if (strcasecmp(buf, MODE_SHORT_STR) == 0) { |
|
|
|
if (strcasecmp(buf, MODE_SHORT_STR) == 0) { |
|
|
|
info->Hs = ICARUS_REV3_HASH_TIME; |
|
|
|
info->read_time = ICARUS_READ_COUNT_TIMING; |
|
|
|
info->read_count = 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->read_time = ICARUS_READ_COUNT_TIMING; |
|
|
|
info->read_count = 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,27 +535,29 @@ 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; |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
// Anything else in buf just uses DEFAULT mode
|
|
|
|
// Anything else in buf just uses DEFAULT mode
|
|
|
|
|
|
|
|
|
|
|
|
info->Hs = ICARUS_REV3_HASH_TIME; |
|
|
|
|
|
|
|
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 +565,10 @@ 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, "%s: cgid %d Init: mode=%s read_time=%dms Hs=%e", |
|
|
|
icarus->device_id, timing_mode_str(info->timing_mode), info->read_count, info->Hs); |
|
|
|
icarus->drv->name, icarus->cgminer_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) |
|
|
|
@ -424,7 +598,7 @@ static uint32_t mask(int work_division) |
|
|
|
return nonce_mask; |
|
|
|
return nonce_mask; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void get_options(int this_option_offset, int *baud, int *work_division, int *fpga_count) |
|
|
|
static void get_options(int this_option_offset, struct cgpu_info *icarus, int *baud, int *work_division, int *fpga_count) |
|
|
|
{ |
|
|
|
{ |
|
|
|
char err_buf[BUFSIZ+1]; |
|
|
|
char err_buf[BUFSIZ+1]; |
|
|
|
char buf[BUFSIZ+1]; |
|
|
|
char buf[BUFSIZ+1]; |
|
|
|
@ -455,9 +629,30 @@ static void get_options(int this_option_offset, int *baud, int *work_division, i |
|
|
|
buf[max] = '\0'; |
|
|
|
buf[max] = '\0'; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
*baud = ICARUS_IO_SPEED; |
|
|
|
switch (icarus->usbdev->ident) { |
|
|
|
*work_division = 2; |
|
|
|
case IDENT_ICA: |
|
|
|
*fpga_count = 2; |
|
|
|
case IDENT_BLT: |
|
|
|
|
|
|
|
case IDENT_LLT: |
|
|
|
|
|
|
|
*baud = ICARUS_IO_SPEED; |
|
|
|
|
|
|
|
*work_division = 2; |
|
|
|
|
|
|
|
*fpga_count = 2; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
case IDENT_AMU: |
|
|
|
|
|
|
|
*baud = ICARUS_IO_SPEED; |
|
|
|
|
|
|
|
*work_division = 1; |
|
|
|
|
|
|
|
*fpga_count = 1; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
// TODO: ?
|
|
|
|
|
|
|
|
case IDENT_CMR1: |
|
|
|
|
|
|
|
case IDENT_CMR2: |
|
|
|
|
|
|
|
*baud = ICARUS_IO_SPEED; |
|
|
|
|
|
|
|
*work_division = 2; |
|
|
|
|
|
|
|
*fpga_count = 2; |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
default: |
|
|
|
|
|
|
|
quit(1, "Icarus get_options() called with invalid %s ident=%d", |
|
|
|
|
|
|
|
icarus->drv->name, icarus->usbdev->ident); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if (*buf) { |
|
|
|
if (*buf) { |
|
|
|
colon = strchr(buf, ':'); |
|
|
|
colon = strchr(buf, ':'); |
|
|
|
@ -508,13 +703,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,68 +722,87 @@ 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, uninitialised_var(work_division), uninitialised_var(fpga_count); |
|
|
|
|
|
|
|
struct cgpu_info *icarus; |
|
|
|
|
|
|
|
int ret, err, amount, tries; |
|
|
|
|
|
|
|
bool ok; |
|
|
|
|
|
|
|
|
|
|
|
int baud, work_division, fpga_count; |
|
|
|
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; |
|
|
|
|
|
|
|
|
|
|
|
get_options(this_option_offset, &baud, &work_division, &fpga_count); |
|
|
|
if (!usb_init(icarus, dev, found)) |
|
|
|
|
|
|
|
goto shin; |
|
|
|
|
|
|
|
|
|
|
|
applog(LOG_DEBUG, "Icarus Detect: Attempting to open %s", devpath); |
|
|
|
get_options(this_option_offset, icarus, &baud, &work_division, &fpga_count); |
|
|
|
|
|
|
|
|
|
|
|
fd = icarus_open2(devpath, baud, true); |
|
|
|
sprintf(devpath, "%d:%d", |
|
|
|
if (unlikely(fd == -1)) { |
|
|
|
(int)(icarus->usbinfo.bus_number), |
|
|
|
applog(LOG_ERR, "Icarus Detect: Failed to open %s", devpath); |
|
|
|
(int)(icarus->usbinfo.device_address)); |
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
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 = 2; |
|
|
|
icarus_gets(nonce_bin, fd, &tv_finish, NULL, 1); |
|
|
|
ok = false; |
|
|
|
|
|
|
|
while (!ok && tries-- > 0) { |
|
|
|
|
|
|
|
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)) |
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
memset(nonce_bin, 0, sizeof(nonce_bin)); |
|
|
|
|
|
|
|
ret = icarus_get_nonce(icarus, nonce_bin, &tv_start, &tv_finish, NULL, 100); |
|
|
|
|
|
|
|
if (ret != ICA_NONCE_OK) |
|
|
|
|
|
|
|
continue; |
|
|
|
|
|
|
|
|
|
|
|
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) == 0) |
|
|
|
applog(LOG_ERR, |
|
|
|
ok = true; |
|
|
|
"Icarus Detect: " |
|
|
|
else { |
|
|
|
"Test failed at %s: get %s, should: %s", |
|
|
|
if (tries < 0) { |
|
|
|
devpath, nonce_hex, golden_nonce); |
|
|
|
applog(LOG_ERR, |
|
|
|
|
|
|
|
"Icarus Detect: " |
|
|
|
|
|
|
|
"Test failed at %s: get %s, should: %s", |
|
|
|
|
|
|
|
devpath, nonce_hex, golden_nonce); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
free(nonce_hex); |
|
|
|
free(nonce_hex); |
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!ok) |
|
|
|
|
|
|
|
goto unshin; |
|
|
|
|
|
|
|
|
|
|
|
applog(LOG_DEBUG, |
|
|
|
applog(LOG_DEBUG, |
|
|
|
"Icarus Detect: " |
|
|
|
"Icarus Detect: " |
|
|
|
"Test succeeded at %s: got %s", |
|
|
|
"Test succeeded at %s: got %s", |
|
|
|
devpath, nonce_hex); |
|
|
|
devpath, golden_nonce); |
|
|
|
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); |
|
|
|
|
|
|
|
icarus->device_fd = -1; |
|
|
|
|
|
|
|
icarus->threads = 1; |
|
|
|
|
|
|
|
add_cgpu(icarus); |
|
|
|
|
|
|
|
icarus_info = realloc(icarus_info, sizeof(struct ICARUS_INFO *) * (total_devices + 1)); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
applog(LOG_INFO, "Found Icarus at %s, mark as %d", |
|
|
|
update_usb_stats(icarus); |
|
|
|
devpath, icarus->device_id); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
applog(LOG_DEBUG, "Icarus: Init: %d baud=%d work_division=%d fpga_count=%d", |
|
|
|
applog(LOG_INFO, "%s%d: Found at %s", |
|
|
|
icarus->device_id, baud, work_division, fpga_count); |
|
|
|
icarus->drv->name, icarus->device_id, devpath); |
|
|
|
|
|
|
|
|
|
|
|
// Since we are adding a new device on the end it needs to always be allocated
|
|
|
|
applog(LOG_DEBUG, "%s%d: Init baud=%d work_division=%d fpga_count=%d", |
|
|
|
icarus_info[icarus->device_id] = (struct ICARUS_INFO *)malloc(sizeof(struct ICARUS_INFO)); |
|
|
|
icarus->drv->name, icarus->device_id, baud, work_division, fpga_count); |
|
|
|
if (unlikely(!(icarus_info[icarus->device_id]))) |
|
|
|
|
|
|
|
|
|
|
|
info = (struct ICARUS_INFO *)malloc(sizeof(struct ICARUS_INFO)); |
|
|
|
|
|
|
|
if (unlikely(!info)) |
|
|
|
quit(1, "Failed to malloc ICARUS_INFO"); |
|
|
|
quit(1, "Failed to malloc ICARUS_INFO"); |
|
|
|
|
|
|
|
|
|
|
|
info = icarus_info[icarus->device_id]; |
|
|
|
icarus->device_data = (void *)info; |
|
|
|
|
|
|
|
|
|
|
|
// Initialise everything to zero for a new device
|
|
|
|
// Initialise everything to zero for a new device
|
|
|
|
memset(info, 0, sizeof(struct ICARUS_INFO)); |
|
|
|
memset(info, 0, sizeof(struct ICARUS_INFO)); |
|
|
|
@ -605,11 +818,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 +843,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,12 +852,9 @@ 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; |
|
|
|
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(icarus->device_data); |
|
|
|
int ret; |
|
|
|
int ret, err, amount; |
|
|
|
|
|
|
|
|
|
|
|
struct ICARUS_INFO *info; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
unsigned char ob_bin[64], nonce_bin[ICARUS_READ_SIZE]; |
|
|
|
unsigned char ob_bin[64], nonce_bin[ICARUS_READ_SIZE]; |
|
|
|
char *ob_hex; |
|
|
|
char *ob_hex; |
|
|
|
uint32_t nonce; |
|
|
|
uint32_t nonce; |
|
|
|
@ -658,65 +868,49 @@ 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
|
|
|
|
elapsed.tv_sec = elapsed.tv_usec = 0; |
|
|
|
return -1; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fd = icarus->device_fd; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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)); |
|
|
|
applog(LOG_ERR, "%s%i: Comms error (werr=%d amt=%d)", |
|
|
|
if (ret) { |
|
|
|
icarus->drv->name, icarus->device_id, err, amount); |
|
|
|
do_icarus_close(thr); |
|
|
|
|
|
|
|
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, "%s%d: sent %s", |
|
|
|
icarus->device_id, ob_hex); |
|
|
|
icarus->drv->name, icarus->device_id, ob_hex); |
|
|
|
free(ob_hex); |
|
|
|
free(ob_hex); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
@ -730,8 +924,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work, |
|
|
|
estimate_hashes = 0xffffffff; |
|
|
|
estimate_hashes = 0xffffffff; |
|
|
|
|
|
|
|
|
|
|
|
if (opt_debug) { |
|
|
|
if (opt_debug) { |
|
|
|
applog(LOG_DEBUG, "Icarus %d no nonce = 0x%08lX hashes (%ld.%06lds)", |
|
|
|
applog(LOG_DEBUG, "%s%d: no nonce = 0x%08lX hashes (%ld.%06lds)", |
|
|
|
icarus->device_id, (long unsigned int)estimate_hashes, |
|
|
|
icarus->drv->name, icarus->device_id, |
|
|
|
|
|
|
|
(long unsigned int)estimate_hashes, |
|
|
|
elapsed.tv_sec, elapsed.tv_usec); |
|
|
|
elapsed.tv_sec, elapsed.tv_usec); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -739,19 +934,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; |
|
|
|
@ -760,8 +947,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work, |
|
|
|
timersub(&tv_finish, &tv_start, &elapsed); |
|
|
|
timersub(&tv_finish, &tv_start, &elapsed); |
|
|
|
|
|
|
|
|
|
|
|
if (opt_debug) { |
|
|
|
if (opt_debug) { |
|
|
|
applog(LOG_DEBUG, "Icarus %d nonce = 0x%08x = 0x%08lX hashes (%ld.%06lds)", |
|
|
|
applog(LOG_DEBUG, "%s%d: nonce = 0x%08x = 0x%08lX hashes (%ld.%06lds)", |
|
|
|
icarus->device_id, nonce, (long unsigned int)hash_count, |
|
|
|
icarus->drv->name, icarus->device_id, |
|
|
|
|
|
|
|
nonce, (long unsigned int)hash_count, |
|
|
|
elapsed.tv_sec, elapsed.tv_usec); |
|
|
|
elapsed.tv_sec, elapsed.tv_usec); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -804,7 +992,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 +1025,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 +1041,8 @@ 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, "%s%d Re-estimate: Hs=%e W=%e read_time=%dms fullnonce=%.3fs", |
|
|
|
applog(LOG_WARNING, "Icarus %d Re-estimate: Hs=%e W=%e read_count=%d fullnonce=%.3fs", |
|
|
|
icarus->drv->name, icarus->device_id, Hs, W, read_time, fullnonce); |
|
|
|
icarus->device_id, Hs, W, read_count, fullnonce); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
info->history_count++; |
|
|
|
info->history_count++; |
|
|
|
cgtime(&tv_history_finish); |
|
|
|
cgtime(&tv_history_finish); |
|
|
|
@ -870,13 +1057,13 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work, |
|
|
|
static struct api_data *icarus_api_stats(struct cgpu_info *cgpu) |
|
|
|
static struct api_data *icarus_api_stats(struct cgpu_info *cgpu) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct api_data *root = NULL; |
|
|
|
struct api_data *root = NULL; |
|
|
|
struct ICARUS_INFO *info = icarus_info[cgpu->device_id]; |
|
|
|
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(cgpu->device_data); |
|
|
|
|
|
|
|
|
|
|
|
// Warning, access to these is not locked - but we don't really
|
|
|
|
// Warning, access to these is not locked - but we don't really
|
|
|
|
// 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 +1083,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 = { |
|
|
|
|
Con Kolivas
12 years ago