@ -1,7 +1,7 @@
@@ -1,7 +1,7 @@
/*
* Copyright 2012 Luke Dashjr
* Copyright 2012 - 2013 Andrew Smith
* 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
* under the terms of the GNU General Public License as published by the Free
@ -29,30 +29,25 @@
@@ -29,30 +29,25 @@
* nonce range is completely calculated .
*/
# include "config.h"
# include "miner.h"
# include <float.h>
# include <limits.h>
# include <pthread.h>
# include <stdint.h>
# include <stdio.h>
# include <strings.h>
# include <sys/time.h>
# include <sys/types.h>
# include <dirent.h>
# include <unistd.h>
# ifndef WIN32
# include <termios.h>
# include <sys/stat.h>
# include <fcntl.h>
# ifndef O_CLOEXEC
# define O_CLOEXEC 0
# endif
# else
# include <windows.h>
# include <io.h>
# include "config.h"
# ifdef WIN32
# include <windows.h>
# endif
# include "elist.h"
# include "fpgautils.h"
# include "compat.h"
# include "miner.h"
# include "usbutils.h"
// The serial I/O speed - Linux uses a define 'B115200' in bits/termios.h
# define ICARUS_IO_SPEED 115200
@ -67,41 +62,53 @@
@@ -67,41 +62,53 @@
# define ASSERT1(condition) __maybe_unused static char sizeof_uint32_t_must_be_4[(condition)?1:-1]
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
// i.e. 10 means 1/10 of a second
# define TIME_FACTOR 10
// It's 10 per second, thus value = 10/TIME_FACTOR =
# define ICARUS_READ_FAULT_DECISECONDS 1
// USB ms timeout to wait
# define ICARUS_WAIT_TIMEOUT 100
// In timing mode: Default starting value until an estimate can be obtained
// 5 seconds allows for up to a ~840MH/s device
# define ICARUS_READ_COUNT_TIMING (5 * TIME_FACTOR)
// 5000 ms allows for up to a ~840MH/s device
# 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)
// Since this rounds up a the last digit - it is a slight overestimate
// Thus the hash rate will be a VERY slight underestimate
// (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 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
// Icarus Rev3 doesn't send a completion message when it finishes
// 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:
// 1) How many hashes were done if the work was aborted
// 2) How high can the timeout be before the Icarus is idle,
// to minimise the number of work started
// We set 2) to 'the calculated estimate' - 1
// to minimise the number of work items started
// We set 2) to 'the calculated estimate' - ICARUS_READ_REDUCE
// to ensure the estimate ends before idle
//
// The simple calculation used is:
// Tn = Total time in seconds to calculate n hashes
// Hs = seconds per hash
// Xn = number of hashes
// W = code overhead per work
// W = code/usb overhead per work
//
// Rough but reasonable estimate:
// Tn = Hs * Xn + W (of the form y = mx + b)
@ -123,7 +130,7 @@ ASSERT1(sizeof(uint32_t) == 4);
@@ -123,7 +130,7 @@ ASSERT1(sizeof(uint32_t) == 4);
# define HISTORY_SEC 60
// Minimum how many points a single ICARUS_HISTORY should have
# 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
static struct timeval history_sec = { HISTORY_SEC , 0 } ;
@ -163,7 +170,8 @@ struct ICARUS_INFO {
@@ -163,7 +170,8 @@ struct ICARUS_INFO {
// seconds per Hash
double Hs ;
int read_count ;
// ms til we abort
int read_time ;
enum timing_mode timing_mode ;
bool do_icarus_timing ;
@ -188,14 +196,12 @@ struct ICARUS_INFO {
@@ -188,14 +196,12 @@ struct ICARUS_INFO {
# define END_CONDITION 0x0000ffff
// One for each possible device
static struct ICARUS_INFO * * icarus_info ;
// Looking for options in --icarus-timing and --icarus-options:
//
// Code increments this each time we start to look at a device
// 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
//
@ -203,13 +209,173 @@ static struct ICARUS_INFO **icarus_info;
@@ -203,13 +209,173 @@ static struct ICARUS_INFO **icarus_info;
// that would be random since an Icarus may fail and thus we'd
// not be able to predict the option order
//
// This also assumes that serial_detect() checks them sequentially
// and in the order specified on the command line
// Devices are checked in the order libusb finds them which is ?
//
static int option_offset = - 1 ;
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 )
{
size_t i , j ;
@ -222,79 +388,64 @@ static void rev(unsigned char *s, size_t l)
@@ -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 icarus_open(devpath, baud) icarus_open2(devpath, baud, false)
# define ICA_GETS_ERROR -1
# define ICA_GETS_OK 0
# define ICA_GETS_RESTART 1
# define ICA_GETS_TIMEOUT 2
# define ICA_NONCE_ERROR -1
# define ICA_NONCE_OK 0
# define ICA_NONCE_RESTART 1
# define ICA_NONCE_TIMEOUT 2
static int icarus_gets ( unsigned char * buf , int fd , struct timeval * tv_finish , struct thr_info * thr , int read_coun t )
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 read_amount = ICARUS_READ_SIZE ;
bool first = true ;
// Read reply 1 byte at a time to get earliest tv_finish
cgtime ( tv_start ) ;
while ( true ) {
ret = read ( fd , buf , 1 ) ;
if ( ret < 0 )
return ICA_GETS_ERROR ;
if ( icarus - > usbinfo . nodev )
return ICA_NONCE_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 )
cgtime ( tv_finish ) ;
if ( ret > = read_amount )
return ICA_GETS_OK ;
if ( ret > 0 ) {
buf + = ret ;
read_amount - = ret ;
first = false ;
continue ;
}
rc + + ;
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 ;
copy_time ( tv_finish , & read_finish ) ;
// TODO: test if there is more data? to read a 2nd nonce?
if ( amt > = read_amount )
return ICA_NONCE_OK ;
rc + = SECTOMS ( tdiff ( & read_finish , & read_start ) ) ;
if ( rc > = read_time ) {
if ( amt > 0 )
applog ( LOG_DEBUG , " Icarus Read: Timeout reading for %d ms " , rc ) ;
else
applog ( LOG_DEBUG , " Icarus Read: No data for %d ms " , rc ) ;
return ICA_NONCE_TIMEOUT ;
}
if ( thr & & thr - > work_restart ) {
if ( opt_debug ) {
applog ( LOG_DEBUG ,
" Icarus Read: Work restart at %.2f seconds " ,
( float ) ( rc ) / ( float ) TIME_FACTOR ) ;
" Icarus Read: Work restart at %d ms " , rc ) ;
}
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 ;
if ( amt > 0 ) {
buf + = amt ;
read_amount - = amt ;
first = false ;
}
}
}
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)
@@ -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 )
{
struct ICARUS_INFO * info = icarus_info [ icarus - > device_id ] ;
struct ICARUS_INFO * info = ( struct ICARUS_INFO * ) ( icarus - > device_data ) ;
double Hs ;
char buf [ BUFSIZ + 1 ] ;
char * ptr , * comma , * eq ;
@ -345,18 +496,37 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
@@ -345,18 +496,37 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
buf [ max ] = ' \0 ' ;
}
info - > Hs = 0 ;
info - > read_count = 0 ;
switch ( icarus - > usbdev - > ident ) {
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 ) {
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 - > do_icarus_timing = true ;
} else if ( strcasecmp ( buf , MODE_LONG_STR ) = = 0 ) {
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 - > do_icarus_timing = true ;
@ -365,27 +535,29 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
@@ -365,27 +535,29 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
info - > fullnonce = info - > Hs * ( ( ( double ) 0xffffffff ) + 1 ) ;
if ( ( eq = strchr ( buf , ' = ' ) ) ! = NULL )
info - > read_coun t = atoi ( eq + 1 ) ;
info - > read_time = atoi ( eq + 1 ) * ICARUS_WAIT_TIMEOUT ;
if ( info - > read_count < 1 )
info - > read_count = ( int ) ( info - > fullnonce * TIME_FACTOR ) - 1 ;
if ( info - > read_time < ICARUS_READ_COUNT_MIN )
info - > read_time = SECTOMS ( info - > fullnonce ) - ICARUS_READ_REDUCE ;
if ( unlikely ( info - > read_count < 1 ) )
info - > read_count = 1 ;
if ( unlikely ( info - > read_time < ICARUS_READ_COUNT_MIN ) )
info - > read_time = ICARUS_READ_COUNT_MIN ;
info - > timing_mode = MODE_VALUE ;
info - > do_icarus_timing = false ;
} else {
// Anything else in buf just uses DEFAULT mode
info - > Hs = ICARUS_REV3_HASH_TIME ;
info - > fullnonce = info - > Hs * ( ( ( double ) 0xffffffff ) + 1 ) ;
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 )
info - > read_count = ( int ) ( info - > fullnonce * TIME_FACTOR ) - 1 ;
if ( unlikely ( info - > read_time < ICARUS_READ_COUNT_MIN ) )
info - > read_time = ICARUS_READ_COUNT_MIN ;
info - > timing_mode = MODE_DEFAULT ;
info - > do_icarus_timing = false ;
@ -393,8 +565,10 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
@@ -393,8 +565,10 @@ static void set_timing_mode(int this_option_offset, struct cgpu_info *icarus)
info - > min_data_count = MIN_DATA_COUNT ;
applog ( LOG_DEBUG , " Icarus: Init: %d mode=%s read_count=%d Hs=%e " ,
icarus - > device_id , timing_mode_str ( info - > timing_mode ) , info - > read_count , info - > Hs ) ;
applog ( LOG_DEBUG , " %s: cgid %d Init: mode=%s read_time=%dms Hs=%e " ,
icarus - > drv - > name , icarus - > cgminer_id ,
timing_mode_str ( info - > timing_mode ) ,
info - > read_time , info - > Hs ) ;
}
static uint32_t mask ( int work_division )
@ -424,7 +598,7 @@ static uint32_t mask(int work_division)
@@ -424,7 +598,7 @@ static uint32_t mask(int work_division)
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 buf [ BUFSIZ + 1 ] ;
@ -455,9 +629,30 @@ static void get_options(int this_option_offset, int *baud, int *work_division, i
@@ -455,9 +629,30 @@ static void get_options(int this_option_offset, int *baud, int *work_division, i
buf [ max ] = ' \0 ' ;
}
* baud = ICARUS_IO_SPEED ;
* work_division = 2 ;
* fpga_count = 2 ;
switch ( icarus - > usbdev - > ident ) {
case IDENT_ICA :
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 ) {
colon = strchr ( buf , ' : ' ) ;
@ -508,13 +703,12 @@ static void get_options(int this_option_offset, int *baud, int *work_division, i
@@ -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 ;
char devpath [ 20 ] ;
struct ICARUS_INFO * info ;
struct timeval tv_start , tv_finish ;
int fd ;
// Block 171874 nonce = (0xa2870100) = 0x000187a2
// N.B. golden_ob MUST take less time to calculate
@ -528,68 +722,87 @@ static bool icarus_detect_one(const char *devpath)
@@ -528,68 +722,87 @@ static bool icarus_detect_one(const char *devpath)
const char golden_nonce [ ] = " 000187a2 " ;
const uint32_t golden_nonce_val = 0x000187a2 ;
unsigned char ob_bin [ 64 ] , nonce_bin [ ICARUS_READ_SIZE ] ;
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 ) ;
if ( unlikely ( fd = = - 1 ) ) {
applog ( LOG_ERR , " Icarus Detect: Failed to open %s " , devpath ) ;
return false ;
}
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 ) ) ;
icarus_write ( fd , ob_bin , sizeof ( ob_bin ) ) ;
cgtime ( & tv_start ) ;
memset ( nonce_bin , 0 , sizeof ( nonce_bin ) ) ;
icarus_gets ( nonce_bin , fd , & tv_finish , NULL , 1 ) ;
tries = 2 ;
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 ) ) ;
if ( strncmp ( nonce_hex , golden_nonce , 8 ) ) {
applog ( LOG_ERR ,
" Icarus Detect: "
" Test failed at %s: get %s, should: %s " ,
devpath , nonce_hex , golden_nonce ) ;
nonce_hex = bin2hex ( nonce_bin , sizeof ( nonce_bin ) ) ;
if ( strncmp ( nonce_hex , golden_nonce , 8 ) = = 0 )
ok = true ;
else {
if ( tries < 0 ) {
applog ( LOG_ERR ,
" Icarus Detect: "
" Test failed at %s: get %s, should: %s " ,
devpath , nonce_hex , golden_nonce ) ;
}
}
free ( nonce_hex ) ;
return false ;
}
if ( ! ok )
goto unshin ;
applog ( LOG_DEBUG ,
" Icarus Detect: "
" Test succeeded at %s: got %s " ,
devpath , nonce_hex ) ;
free ( nonce_hex ) ;
devpath , golden_nonce ) ;
/* We have a real Icarus! */
struct cgpu_info * icarus ;
icarus = calloc ( 1 , sizeof ( struct cgpu_info ) ) ;
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 ) ) ;
if ( ! add_cgpu ( icarus ) )
goto unshin ;
applog ( LOG_INFO , " Found Icarus at %s, mark as %d " ,
devpath , icarus - > device_id ) ;
update_usb_stats ( icarus ) ;
applog ( LOG_DEBUG , " Icarus: Init: %d baud=%d work_division=%d fpga_count=%d " ,
icarus - > device_id , baud , work_division , fpga_count ) ;
applog ( LOG_INFO , " %s%d: Found at %s " ,
icarus - > drv - > name , icarus - > device_id , devpath ) ;
// Since we are adding a new device on the end it needs to always be allocated
icarus_info [ icarus - > device_id ] = ( struct ICARUS_INFO * ) malloc ( sizeof ( struct ICARUS_INFO ) ) ;
if ( unlikely ( ! ( icarus_info [ icarus - > device_id ] ) ) )
applog ( LOG_DEBUG , " %s%d: Init baud=%d work_division=%d fpga_count=%d " ,
icarus - > drv - > name , icarus - > device_id , baud , work_division , fpga_count ) ;
info = ( struct ICARUS_INFO * ) malloc ( sizeof ( struct ICARUS_INFO ) ) ;
if ( unlikely ( ! 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
memset ( info , 0 , sizeof ( struct ICARUS_INFO ) ) ;
@ -605,11 +818,23 @@ static bool icarus_detect_one(const char *devpath)
@@ -605,11 +818,23 @@ static bool icarus_detect_one(const char *devpath)
set_timing_mode ( this_option_offset , icarus ) ;
return true ;
unshin :
usb_uninit ( icarus ) ;
free ( icarus - > device_path ) ;
shin :
free ( icarus ) ;
return false ;
}
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 )
@ -618,18 +843,6 @@ static bool icarus_prepare(struct thr_info *thr)
@@ -618,18 +843,6 @@ static bool icarus_prepare(struct thr_info *thr)
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 ) ;
get_datestamp ( icarus - > init , & now ) ;
@ -639,12 +852,9 @@ static bool icarus_prepare(struct thr_info *thr)
@@ -639,12 +852,9 @@ static bool icarus_prepare(struct thr_info *thr)
static int64_t icarus_scanhash ( struct thr_info * thr , struct work * work ,
__maybe_unused int64_t max_nonce )
{
struct cgpu_info * icarus ;
int fd ;
int ret ;
struct ICARUS_INFO * info ;
struct cgpu_info * icarus = thr - > cgpu ;
struct ICARUS_INFO * info = ( struct ICARUS_INFO * ) ( icarus - > device_data ) ;
int ret , err , amount ;
unsigned char ob_bin [ 64 ] , nonce_bin [ ICARUS_READ_SIZE ] ;
char * ob_hex ;
uint32_t nonce ;
@ -658,65 +868,49 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -658,65 +868,49 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
struct ICARUS_HISTORY * history0 , * history ;
int count ;
double Hs , W , fullnonce ;
int read_coun t ;
int read_time ;
int64_t estimate_hashes ;
uint32_t values ;
int64_t hash_count_range ;
elapsed . tv_sec = elapsed . tv_usec = 0 ;
icarus = thr - > cgpu ;
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 ) ;
// Device is gone
if ( icarus - > usbinfo . nodev )
return - 1 ;
// fail the device if the reopen attempt fails
return - 1 ;
}
fd = icarus - > device_fd ;
elapsed . tv_sec = elapsed . tv_usec = 0 ;
memset ( ob_bin , 0 , sizeof ( ob_bin ) ) ;
memcpy ( ob_bin , work - > midstate , 32 ) ;
memcpy ( ob_bin + 52 , work - > data + 64 , 12 ) ;
rev ( ob_bin , 32 ) ;
rev ( ob_bin + 52 , 12 ) ;
# ifndef WIN32
tcflush ( fd , TCOFLUSH ) ;
# endif
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 ) ;
err = usb_write ( icarus , ( char * ) ob_bin , sizeof ( ob_bin ) , & amount , C_SENDWORK ) ;
if ( err < 0 | | amount ! = sizeof ( ob_bin ) ) {
applog ( LOG_ERR , " %s%i: Comms error (werr=%d amt=%d) " ,
icarus - > drv - > name , icarus - > device_id , err , amount ) ;
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 ) {
ob_hex = bin2hex ( ob_bin , sizeof ( ob_bin ) ) ;
applog ( LOG_DEBUG , " Icarus %d sent: %s" ,
icarus - > device_id , ob_hex ) ;
applog ( LOG_DEBUG , " %s%d: sent %s" ,
icarus - > drv - > name , icarus - > d evice_id , ob_hex ) ;
free ( ob_hex ) ;
}
/* Icarus will return 4 bytes (ICARUS_READ_SIZE) nonces or nothing */
memset ( nonce_bin , 0 , sizeof ( nonce_bin ) ) ;
info = icarus_info [ icarus - > device_id ] ;
ret = icarus_gets ( nonce_bin , fd , & tv_finish , thr , info - > read_count ) ;
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 ) ;
ret = icarus_get_nonce ( icarus , nonce_bin , & tv_start , & tv_finish , thr , info - > read_time ) ;
if ( ret = = ICA_NONCE_ERROR )
return 0 ;
}
work - > blk . nonce = 0xffffffff ;
// 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 ) ;
// ONLY up to just when it aborted
@ -730,8 +924,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -730,8 +924,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
estimate_hashes = 0xffffffff ;
if ( opt_debug ) {
applog ( LOG_DEBUG , " Icarus %d no nonce = 0x%08lX hashes (%ld.%06lds) " ,
icarus - > device_id , ( long unsigned int ) estimate_hashes ,
applog ( LOG_DEBUG , " %s%d: no nonce = 0x%08lX hashes (%ld.%06lds) " ,
icarus - > drv - > name , icarus - > device_id ,
( long unsigned int ) estimate_hashes ,
elapsed . tv_sec , elapsed . tv_usec ) ;
}
@ -739,19 +934,11 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -739,19 +934,11 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
}
memcpy ( ( char * ) & nonce , nonce_bin , sizeof ( nonce_bin ) ) ;
# if !defined (__BIG_ENDIAN__) && !defined(MIPSEB)
nonce = swab32 ( nonce ) ;
# endif
nonce = htobe32 ( nonce ) ;
curr_hw_errors = icarus - > hw_errors ;
submit_nonce ( thr , work , nonce ) ;
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 + + ;
hash_count * = info - > fpga_count ;
@ -760,8 +947,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -760,8 +947,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
timersub ( & tv_finish , & tv_start , & elapsed ) ;
if ( opt_debug ) {
applog ( LOG_DEBUG , " Icarus %d nonce = 0x%08x = 0x%08lX hashes (%ld.%06lds) " ,
icarus - > device_id , nonce , ( long unsigned int ) hash_count ,
applog ( LOG_DEBUG , " %s%d: nonce = 0x%08x = 0x%08lX hashes (%ld.%06lds) " ,
icarus - > drv - > name , icarus - > device_id ,
nonce , ( long unsigned int ) hash_count ,
elapsed . tv_sec , elapsed . tv_usec ) ;
}
@ -804,7 +992,7 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -804,7 +992,7 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
memset ( history0 , 0 , sizeof ( struct ICARUS_HISTORY ) ) ;
// We just completed a history data set
// So now recalc read_coun t 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
// total data sets
count = 0 ;
@ -837,10 +1025,10 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -837,10 +1025,10 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
memset ( history0 , 0 , sizeof ( struct ICARUS_HISTORY ) ) ;
fullnonce = W + Hs * ( ( ( double ) 0xffffffff ) + 1 ) ;
read_count = ( int ) ( fullnonce * TIME_FACTOR ) - 1 ;
read_time = SECTOMS ( fullnonce ) - ICARUS_READ_REDUCE ;
info - > Hs = Hs ;
info - > read_coun t = read_coun t ;
info - > read_time = read_time ;
info - > fullnonce = fullnonce ;
info - > count = count ;
@ -853,9 +1041,8 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -853,9 +1041,8 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
else if ( info - > timing_mode = = MODE_SHORT )
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: Hs=%e W=%e read_count=%d fullnonce=%.3fs " ,
icarus - > device_id , Hs , W , read_count , fullnonce ) ;
applog ( LOG_WARNING , " %s%d Re-estimate: Hs=%e W=%e read_time=%dms fullnonce=%.3fs " ,
icarus - > drv - > name , icarus - > device_id , Hs , W , read_time , fullnonce ) ;
}
info - > history_count + + ;
cgtime ( & tv_history_finish ) ;
@ -870,13 +1057,13 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
@@ -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 )
{
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
// care since hashing performance is way more important than
// locking access to displaying API debug 'stats'
// If locking becomes an issue for any of them, use copy_data=true also
root = api_add_int ( root , " read_coun t " , & ( info - > read_coun t ) , false ) ;
root = api_add_int ( root , " read_time " , & ( info - > read_time ) , false ) ;
root = api_add_double ( root , " fullnonce " , & ( info - > fullnonce ) , false ) ;
root = api_add_int ( root , " count " , & ( info - > count ) , 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)
@@ -896,9 +1083,9 @@ static struct api_data *icarus_api_stats(struct cgpu_info *cgpu)
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 = {
Con Kolivas
12 years ago