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

Merge branch 'master' into async 

Conflicts:
	usbutils.c
nfactor-troky
Con Kolivas 11 years ago
parent
39ec9518d5 b30ae4a216
commit
853aa28ffc
6 changed files with 288 additions and 61 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. 13
      API-README
  2. 3
      cgminer.c
  3. 74
      driver-bitfury.c
  4. 3
      driver-bitfury.h
  5. 239
      driver-icarus.c
  6. 17
      usbutils.c

13
API-README
Unescape View File

@ -277,13 +277,13 @@ The list of requests - a (*) means it requires privileged access - and replies:
none There is no reply section just the STATUS section none There is no reply section just the STATUS section
stating the results of the identify request stating the results of the identify request
This is only available if PGA mining is enabled This is only available if PGA mining is enabled
and currently only BFL singles support this and currently only BFL singles and Cairnsmore1's
command with the appropriate firmware support this command
On a BFL single it will flash the led on the front On a BFL single it will flash the led on the front
of the device for appoximately 4s of the device for appoximately 4s
All other non BFL PGA devices will return a All other non BFL,ICA PGA devices will return a
warning status message stating that they dont warning status message stating that they dont
support it support it. Non-CMR ICAs will ignore the command.
This adds a 4s delay to the BFL share being This adds a 4s delay to the BFL share being
processed so you may get a message stating that processed so you may get a message stating that
procssing took longer than 7000ms if the request procssing took longer than 7000ms if the request
@ -364,6 +364,7 @@ The list of requests - a (*) means it requires privileged access - and replies:
The current options are: The current options are:
MMQ opt=clock val=160 to 230 (a multiple of 2) MMQ opt=clock val=160 to 230 (a multiple of 2)
CMR opt=clock val=100 to 220
zero|Which,true/false (*) zero|Which,true/false (*)
none There is no reply section just the STATUS section none There is no reply section just the STATUS section
@ -433,8 +434,8 @@ The list of requests - a (*) means it requires privileged access - and replies:
help message about the options available help message about the options available
The current options are: The current options are:
AVA+BTB opt=freq val=256 to 450 - chip frequency AVA+BTB opt=freq val=256 to 1024 - chip frequency
BTB opt=millivolts val=1000 to 1310 - corevoltage BTB opt=millivolts val=1000 to 1400 - corevoltage
When you enable, disable or restart a GPU, PGA or ASC, you will also get When you enable, disable or restart a GPU, PGA or ASC, you will also get
Thread messages in the cgminer status window Thread messages in the cgminer status window

3
cgminer.c
Unescape View File

@ -6254,7 +6254,8 @@ static void hash_sole_work(struct thr_info *mythr)
applog(LOG_ERR, "%s %d failure, disabling!", drv->name, cgpu->device_id); applog(LOG_ERR, "%s %d failure, disabling!", drv->name, cgpu->device_id);
cgpu->deven = DEV_DISABLED; cgpu->deven = DEV_DISABLED;
dev_error(cgpu, REASON_THREAD_ZERO_HASH); dev_error(cgpu, REASON_THREAD_ZERO_HASH);
mt_disable(mythr, thr_id, drv); cgpu->shutdown = true;
break;
} }
hashes_done += hashes; hashes_done += hashes;

74
driver-bitfury.c
Unescape View File

@ -15,6 +15,8 @@
/* Wait longer 1/3 longer than it would take for a full nonce range */ /* Wait longer 1/3 longer than it would take for a full nonce range */
#define BF1WAIT 1600 #define BF1WAIT 1600
#define BF1MSGSIZE 7
#define BF1INFOSIZE 14
static void bitfury_empty_buffer(struct cgpu_info *bitfury) static void bitfury_empty_buffer(struct cgpu_info *bitfury)
{ {
@ -26,18 +28,29 @@ static void bitfury_empty_buffer(struct cgpu_info *bitfury)
} while (amount); } while (amount);
} }
static void bitfury_open(struct cgpu_info *bitfury) static int bitfury_open(struct cgpu_info *bitfury)
{ {
uint32_t buf[2]; uint32_t buf[2];
int err;
bitfury_empty_buffer(bitfury); bitfury_empty_buffer(bitfury);
/* Magic sequence to reset device only really needed for windows but /* Magic sequence to reset device only really needed for windows but
* harmless on linux. */ * harmless on linux. */
buf[0] = 0x80250000; buf[0] = 0x80250000;
buf[1] = 0x00000800; buf[1] = 0x00000800;
usb_transfer(bitfury, 0, 9, 1, 0, C_BF1_RESET); err = usb_transfer(bitfury, 0, 9, 1, 0, C_BF1_RESET);
usb_transfer(bitfury, 0x21, 0x22, 0, 0, C_BF1_OPEN); if (!err)
usb_transfer_data(bitfury, 0x21, 0x20, 0x0000, 0, buf, 7, C_BF1_INIT); err = usb_transfer(bitfury, 0x21, 0x22, 0, 0, C_BF1_OPEN);
if (!err) {
err = usb_transfer_data(bitfury, 0x21, 0x20, 0x0000, 0, buf,
BF1MSGSIZE, C_BF1_INIT);
}
if (err < 0) {
applog(LOG_INFO, "%s %d: Failed to open with error %s", bitfury->drv->name,
bitfury->device_id, libusb_error_name(err));
}
return (err == BF1MSGSIZE);
} }
static void bitfury_close(struct cgpu_info *bitfury) static void bitfury_close(struct cgpu_info *bitfury)
@ -63,15 +76,15 @@ static bool bitfury_getinfo(struct cgpu_info *bitfury, struct bitfury_info *info
bitfury->drv->name, bitfury->device_id); bitfury->drv->name, bitfury->device_id);
return false; return false;
} }
err = usb_read(bitfury, buf, 14, &amount, C_BF1_GETINFO); err = usb_read(bitfury, buf, BF1INFOSIZE, &amount, C_BF1_GETINFO);
if (err) { if (err) {
applog(LOG_INFO, "%s %d: Failed to read GETINFO", applog(LOG_INFO, "%s %d: Failed to read GETINFO",
bitfury->drv->name, bitfury->device_id); bitfury->drv->name, bitfury->device_id);
return false; return false;
} }
if (amount != 14) { if (amount != BF1INFOSIZE) {
applog(LOG_INFO, "%s %d: Getinfo received %d bytes instead of 14", applog(LOG_INFO, "%s %d: Getinfo received %d bytes instead of %d",
bitfury->drv->name, bitfury->device_id, amount); bitfury->drv->name, bitfury->device_id, amount, BF1INFOSIZE);
return false; return false;
} }
info->version = buf[1]; info->version = buf[1];
@ -95,15 +108,16 @@ static bool bitfury_reset(struct cgpu_info *bitfury)
bitfury->drv->name, bitfury->device_id); bitfury->drv->name, bitfury->device_id);
return false; return false;
} }
err = usb_read_timeout(bitfury, buf, 7, &amount, BF1WAIT, C_BF1_GETRESET); err = usb_read_timeout(bitfury, buf, BF1MSGSIZE, &amount, BF1WAIT,
C_BF1_GETRESET);
if (err) { if (err) {
applog(LOG_INFO, "%s %d: Failed to read GETRESET", applog(LOG_INFO, "%s %d: Failed to read GETRESET",
bitfury->drv->name, bitfury->device_id); bitfury->drv->name, bitfury->device_id);
return false; return false;
} }
if (amount != 7) { if (amount != BF1MSGSIZE) {
applog(LOG_INFO, "%s %d: Getreset received %d bytes instead of 7", applog(LOG_INFO, "%s %d: Getreset received %d bytes instead of %d",
bitfury->drv->name, bitfury->device_id, amount); bitfury->drv->name, bitfury->device_id, amount, BF1MSGSIZE);
return false; return false;
} }
applog(LOG_DEBUG, "%s %d: Getreset returned %s", bitfury->drv->name, applog(LOG_DEBUG, "%s %d: Getreset returned %s", bitfury->drv->name,
@ -128,10 +142,14 @@ static bool bitfury_detect_one(struct libusb_device *dev, struct usb_find_device
if (!info) if (!info)
quit(1, "Failed to calloc info in bitfury_detect_one"); quit(1, "Failed to calloc info in bitfury_detect_one");
bitfury->device_data = info; bitfury->device_data = info;
/* This does not artificially raise hashrate, it simply allows the
* hashrate to adapt quickly on starting. */
info->total_nonces = 1;
usb_buffer_enable(bitfury); usb_buffer_enable(bitfury);
bitfury_open(bitfury); if (!bitfury_open(bitfury))
goto out_close;
/* Send getinfo request */ /* Send getinfo request */
if (!bitfury_getinfo(bitfury, info)) if (!bitfury_getinfo(bitfury, info))
@ -145,7 +163,7 @@ static bool bitfury_detect_one(struct libusb_device *dev, struct usb_find_device
bitfury_empty_buffer(bitfury); bitfury_empty_buffer(bitfury);
if (!add_cgpu(bitfury)) if (!add_cgpu(bitfury))
goto out_close; quit(1, "Failed to add_cgpu in bitfury_detect_one");
update_usb_stats(bitfury); update_usb_stats(bitfury);
applog(LOG_INFO, "%s %d: Successfully initialised %s", applog(LOG_INFO, "%s %d: Successfully initialised %s",
@ -208,6 +226,8 @@ static int64_t bitfury_scanhash(struct thr_info *thr, struct work *work,
struct cgpu_info *bitfury = thr->cgpu; struct cgpu_info *bitfury = thr->cgpu;
struct bitfury_info *info = bitfury->device_data; struct bitfury_info *info = bitfury->device_data;
struct timeval tv_now; struct timeval tv_now;
double nonce_rate;
int64_t ret = 0;
int amount, i; int amount, i;
char buf[45]; char buf[45];
int ms_diff; int ms_diff;
@ -235,7 +255,8 @@ static int64_t bitfury_scanhash(struct thr_info *thr, struct work *work,
ms_diff = BF1WAIT - ms_tdiff(&tv_now, &info->tv_start); ms_diff = BF1WAIT - ms_tdiff(&tv_now, &info->tv_start);
if (unlikely(ms_diff < 10)) if (unlikely(ms_diff < 10))
ms_diff = 10; ms_diff = 10;
usb_read_once_timeout(bitfury, info->buf + info->tot, 7, &amount, ms_diff, C_BF1_GETRES); usb_read_once_timeout(bitfury, info->buf + info->tot, BF1MSGSIZE,
&amount, ms_diff, C_BF1_GETRES);
info->tot += amount; info->tot += amount;
while (amount) { while (amount) {
usb_read_once_timeout(bitfury, info->buf + info->tot, 512, &amount, 10, C_BF1_GETRES); usb_read_once_timeout(bitfury, info->buf + info->tot, 512, &amount, 10, C_BF1_GETRES);
@ -249,7 +270,7 @@ static int64_t bitfury_scanhash(struct thr_info *thr, struct work *work,
usb_write(bitfury, buf, 45, &amount, C_BF1_REQWORK); usb_write(bitfury, buf, 45, &amount, C_BF1_REQWORK);
cgtime(&info->tv_start); cgtime(&info->tv_start);
/* Get response acknowledging work */ /* Get response acknowledging work */
usb_read(bitfury, buf, 7, &amount, C_BF1_GETWORK); usb_read(bitfury, buf, BF1MSGSIZE, &amount, C_BF1_GETWORK);
/* Only happens on startup */ /* Only happens on startup */
if (unlikely(!info->prevwork[BF1ARRAY_SIZE])) if (unlikely(!info->prevwork[BF1ARRAY_SIZE]))
@ -257,7 +278,7 @@ static int64_t bitfury_scanhash(struct thr_info *thr, struct work *work,
/* Search for what work the nonce matches in order of likelihood. Last /* Search for what work the nonce matches in order of likelihood. Last
* entry is end of result marker. */ * entry is end of result marker. */
for (i = 0; i < info->tot - 7; i += 7) { for (i = 0; i < info->tot - BF1MSGSIZE; i += BF1MSGSIZE) {
uint32_t nonce; uint32_t nonce;
int j; int j;
@ -279,23 +300,30 @@ cascade:
info->prevwork[i] = info->prevwork[i - 1]; info->prevwork[i] = info->prevwork[i - 1];
info->prevwork[0] = copy_work(work); info->prevwork[0] = copy_work(work);
work->blk.nonce = 0xffffffff; work->blk.nonce = 0xffffffff;
if (info->nonces) {
info->nonces--; info->cycles++;
return (int64_t)0xffffffff; info->total_nonces += info->nonces;
info->saved_nonces += info->nonces;
info->nonces = 0;
nonce_rate = (double)info->total_nonces / (double)info->cycles;
if (info->saved_nonces >= nonce_rate) {
info->saved_nonces -= nonce_rate;
ret = (double)0xffffffff * nonce_rate;
} }
if (unlikely(bitfury->usbinfo.nodev)) { if (unlikely(bitfury->usbinfo.nodev)) {
applog(LOG_WARNING, "%s %d: Device disappeared, disabling thread", applog(LOG_WARNING, "%s %d: Device disappeared, disabling thread",
bitfury->drv->name, bitfury->device_id); bitfury->drv->name, bitfury->device_id);
return -1; ret = -1;
} }
return 0; return ret;
} }
static struct api_data *bitfury_api_stats(struct cgpu_info *cgpu) static struct api_data *bitfury_api_stats(struct cgpu_info *cgpu)
{ {
struct bitfury_info *info = cgpu->device_data; struct bitfury_info *info = cgpu->device_data;
struct api_data *root = NULL; struct api_data *root = NULL;
double nonce_rate;
char serial[16]; char serial[16];
int version; int version;
@ -304,6 +332,8 @@ static struct api_data *bitfury_api_stats(struct cgpu_info *cgpu)
root = api_add_string(root, "Product", info->product, false); root = api_add_string(root, "Product", info->product, false);
sprintf(serial, "%08x", info->serial); sprintf(serial, "%08x", info->serial);
root = api_add_string(root, "Serial", serial, true); root = api_add_string(root, "Serial", serial, true);
nonce_rate = (double)info->total_nonces / (double)info->cycles;
root = api_add_double(root, "NonceRate", &nonce_rate, true);
return root; return root;
} }

3
driver-bitfury.h
Unescape View File

@ -24,6 +24,9 @@ struct bitfury_info {
char buf[512]; char buf[512];
int tot; int tot;
int nonces; int nonces;
int total_nonces;
double saved_nonces;
int cycles;
struct timeval tv_start; struct timeval tv_start;
}; };

239
driver-icarus.c
Unescape View File

@ -108,6 +108,8 @@ ASSERT1(sizeof(uint32_t) == 4);
#define CAIRNSMORE2_HASH_TIME 0.0000000066600 #define CAIRNSMORE2_HASH_TIME 0.0000000066600
#define NANOSEC 1000000000.0 #define NANOSEC 1000000000.0
#define CAIRNSMORE2_INTS 4
// 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 item) shortly before it finishes // work (by starting a new work item) shortly before it finishes
@ -178,6 +180,7 @@ static const char *MODE_VALUE_STR = "value";
static const char *MODE_UNKNOWN_STR = "unknown"; static const char *MODE_UNKNOWN_STR = "unknown";
struct ICARUS_INFO { struct ICARUS_INFO {
enum sub_ident ident;
int intinfo; int intinfo;
// time to calculate the golden_ob // time to calculate the golden_ob
@ -216,17 +219,43 @@ struct ICARUS_INFO {
int fpga_count; int fpga_count;
uint32_t nonce_mask; uint32_t nonce_mask;
bool initialised; uint8_t cmr2_speed;
bool speed_next_work;
bool flash_next_work;
}; };
#define ICARUS_MIDSTATE_SIZE 32 #define ICARUS_MIDSTATE_SIZE 32
#define ICARUS_UNUSED_SIZE 20 #define ICARUS_UNUSED_SIZE 16
#define ICARUS_WORK_SIZE 12 #define ICARUS_WORK_SIZE 12
#define ICARUS_WORK_DATA_OFFSET 64 #define ICARUS_WORK_DATA_OFFSET 64
#define ICARUS_CMR2_SPEED_FACTOR 2.5
#define ICARUS_CMR2_SPEED_MIN_INT 100
#define ICARUS_CMR2_SPEED_DEF_INT 180
#define ICARUS_CMR2_SPEED_MAX_INT 220
#define CMR2_INT_TO_SPEED(_speed) ((uint8_t)((float)_speed / ICARUS_CMR2_SPEED_FACTOR))
#define ICARUS_CMR2_SPEED_MIN CMR2_INT_TO_SPEED(ICARUS_CMR2_SPEED_MIN_INT)
#define ICARUS_CMR2_SPEED_DEF CMR2_INT_TO_SPEED(ICARUS_CMR2_SPEED_DEF_INT)
#define ICARUS_CMR2_SPEED_MAX CMR2_INT_TO_SPEED(ICARUS_CMR2_SPEED_MAX_INT)
#define ICARUS_CMR2_SPEED_INC 1
#define ICARUS_CMR2_SPEED_DEC -1
#define ICARUS_CMR2_SPEED_FAIL -10
#define ICARUS_CMR2_PREFIX ((uint8_t)0xB7)
#define ICARUS_CMR2_CMD_SPEED ((uint8_t)0)
#define ICARUS_CMR2_CMD_FLASH ((uint8_t)1)
#define ICARUS_CMR2_DATA_FLASH_OFF ((uint8_t)0)
#define ICARUS_CMR2_DATA_FLASH_ON ((uint8_t)1)
#define ICARUS_CMR2_CHECK ((uint8_t)0x6D)
struct ICARUS_WORK { struct ICARUS_WORK {
uint8_t midstate[ICARUS_MIDSTATE_SIZE]; uint8_t midstate[ICARUS_MIDSTATE_SIZE];
// These 4 bytes are for CMR2 bitstreams that handle MHz adjustment
uint8_t check;
uint8_t data;
uint8_t cmd;
uint8_t prefix;
uint8_t unused[ICARUS_UNUSED_SIZE]; uint8_t unused[ICARUS_UNUSED_SIZE];
uint8_t work[ICARUS_WORK_SIZE]; uint8_t work[ICARUS_WORK_SIZE];
}; };
@ -423,8 +452,6 @@ static void icarus_initialise(struct cgpu_info *icarus, int baud)
quit(1, "icarus_intialise() called with invalid %s cgid %i ident=%d", quit(1, "icarus_intialise() called with invalid %s cgid %i ident=%d",
icarus->drv->name, icarus->cgminer_id, ident); icarus->drv->name, icarus->cgminer_id, ident);
} }
info->initialised = true;
} }
static void rev(unsigned char *s, size_t l) static void rev(unsigned char *s, size_t l)
@ -820,9 +847,10 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
char *nonce_hex; char *nonce_hex;
int baud, uninitialised_var(work_division), uninitialised_var(fpga_count); int baud, uninitialised_var(work_division), uninitialised_var(fpga_count);
struct cgpu_info *icarus; struct cgpu_info *icarus;
int ret, err, amount, tries; int ret, err, amount, tries, i;
enum sub_ident ident;
bool ok; bool ok;
bool cmr2_ok[CAIRNSMORE2_INTS];
int cmr2_count;
if ((sizeof(workdata) << 1) != (sizeof(golden_ob) - 1)) if ((sizeof(workdata) << 1) != (sizeof(golden_ob) - 1))
quithere(1, "Data and golden_ob sizes don't match"); quithere(1, "Data and golden_ob sizes don't match");
@ -843,8 +871,8 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
quit(1, "Failed to malloc ICARUS_INFO"); quit(1, "Failed to malloc ICARUS_INFO");
icarus->device_data = (void *)info; icarus->device_data = (void *)info;
ident = usb_ident(icarus); info->ident = usb_ident(icarus);
switch (ident) { switch (info->ident) {
case IDENT_ICA: case IDENT_ICA:
case IDENT_BLT: case IDENT_BLT:
case IDENT_LLT: case IDENT_LLT:
@ -853,19 +881,32 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
info->timeout = ICARUS_WAIT_TIMEOUT; info->timeout = ICARUS_WAIT_TIMEOUT;
break; break;
case IDENT_CMR2: case IDENT_CMR2:
if (found->intinfo_count != CAIRNSMORE2_INTS) {
quithere(1, "CMR2 Interface count (%d) isn't expected: %d",
found->intinfo_count,
CAIRNSMORE2_INTS);
}
info->timeout = ICARUS_CMR2_TIMEOUT; info->timeout = ICARUS_CMR2_TIMEOUT;
cmr2_count = 0;
for (i = 0; i < CAIRNSMORE2_INTS; i++)
cmr2_ok[i] = false;
break; break;
default: default:
quit(1, "%s icarus_detect_one() invalid %s ident=%d", quit(1, "%s icarus_detect_one() invalid %s ident=%d",
icarus->drv->dname, icarus->drv->dname, ident); icarus->drv->dname, icarus->drv->dname, info->ident);
} }
// For CMR2 test each USB Interface
cmr2_retry:
tries = 2; tries = 2;
ok = false; ok = false;
while (!ok && tries-- > 0) { while (!ok && tries-- > 0) {
icarus_initialise(icarus, baud); icarus_initialise(icarus, baud);
err = usb_write(icarus, (void *)(&workdata), sizeof(workdata), &amount, C_SENDTESTWORK); err = usb_write_ii(icarus, info->intinfo,
(char *)(&workdata), sizeof(workdata), &amount, C_SENDWORK);
if (err != LIBUSB_SUCCESS || amount != sizeof(workdata)) if (err != LIBUSB_SUCCESS || amount != sizeof(workdata))
continue; continue;
@ -879,7 +920,7 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
if (strncmp(nonce_hex, golden_nonce, 8) == 0) if (strncmp(nonce_hex, golden_nonce, 8) == 0)
ok = true; ok = true;
else { else {
if (tries < 0) { if (tries < 0 && info->ident != IDENT_CMR2) {
applog(LOG_ERR, applog(LOG_ERR,
"Icarus Detect: " "Icarus Detect: "
"Test failed at %s: get %s, should: %s", "Test failed at %s: get %s, should: %s",
@ -889,13 +930,50 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
free(nonce_hex); free(nonce_hex);
} }
if (!ok) if (!ok) {
goto unshin; if (info->ident != IDENT_CMR2)
goto unshin;
if (info->intinfo < CAIRNSMORE2_INTS-1) {
info->intinfo++;
goto cmr2_retry;
}
} else {
if (info->ident == IDENT_CMR2) {
applog(LOG_DEBUG,
"Icarus Detect: "
"Test succeeded at %s i%d: got %s",
icarus->device_path, info->intinfo, golden_nonce);
cmr2_ok[info->intinfo] = true;
cmr2_count++;
if (info->intinfo < CAIRNSMORE2_INTS-1) {
info->intinfo++;
goto cmr2_retry;
}
}
}
applog(LOG_DEBUG, if (info->ident == IDENT_CMR2) {
"Icarus Detect: " if (cmr2_count == 0) {
"Test succeeded at %s: got %s", applog(LOG_ERR,
icarus->device_path, golden_nonce); "Icarus Detect: Test failed at %s: for all %d CMR2 Interfaces",
icarus->device_path, CAIRNSMORE2_INTS);
goto unshin;
}
// set the interface to the first one that succeeded
for (i = 0; i < CAIRNSMORE2_INTS; i++)
if (cmr2_ok[i]) {
info->intinfo = i;
break;
}
} else {
applog(LOG_DEBUG,
"Icarus Detect: "
"Test succeeded at %s: got %s",
icarus->device_path, golden_nonce);
}
/* We have a real Icarus! */ /* We have a real Icarus! */
if (!add_cgpu(icarus)) if (!add_cgpu(icarus))
@ -906,6 +984,18 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
applog(LOG_INFO, "%s%d: Found at %s", applog(LOG_INFO, "%s%d: Found at %s",
icarus->drv->name, icarus->device_id, icarus->device_path); icarus->drv->name, icarus->device_id, icarus->device_path);
if (info->ident == IDENT_CMR2) {
applog(LOG_INFO, "%s%d: with %d Interface%s",
icarus->drv->name, icarus->device_id,
cmr2_count, cmr2_count > 1 ? "s" : "");
// Assume 1 or 2 are running FPGA pairs
if (cmr2_count < 3) {
work_division = fpga_count = 2;
info->Hs /= 2;
}
}
applog(LOG_DEBUG, "%s%d: Init baud=%d work_division=%d fpga_count=%d", 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); icarus->drv->name, icarus->device_id, baud, work_division, fpga_count);
@ -919,12 +1009,15 @@ static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices
set_timing_mode(this_option_offset, icarus); set_timing_mode(this_option_offset, icarus);
if (usb_ident(icarus) == IDENT_CMR2) { if (info->ident == IDENT_CMR2) {
int i; int i;
for (i = 1; i < icarus->usbdev->found->intinfo_count; i++) { for (i = info->intinfo + 1; i < icarus->usbdev->found->intinfo_count; i++) {
struct cgpu_info *cgtmp; struct cgpu_info *cgtmp;
struct ICARUS_INFO *intmp; struct ICARUS_INFO *intmp;
if (!cmr2_ok[i])
continue;
cgtmp = usb_copy_cgpu(icarus); cgtmp = usb_copy_cgpu(icarus);
if (!cgtmp) { if (!cgtmp) {
applog(LOG_ERR, "%s%d: Init failed initinfo %d", applog(LOG_ERR, "%s%d: Init failed initinfo %d",
@ -984,6 +1077,45 @@ static bool icarus_prepare(__maybe_unused struct thr_info *thr)
return true; return true;
} }
static void cmr2_command(struct cgpu_info *icarus, uint8_t cmd, uint8_t data)
{
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(icarus->device_data);
struct ICARUS_WORK workdata;
int amount;
memset((void *)(&workdata), 0, sizeof(workdata));
workdata.prefix = ICARUS_CMR2_PREFIX;
workdata.cmd = cmd;
workdata.data = data;
workdata.check = workdata.data ^ workdata.cmd ^ workdata.prefix ^ ICARUS_CMR2_CHECK;
usb_write_ii(icarus, info->intinfo, (char *)(&workdata), sizeof(workdata), &amount, C_SENDWORK);
}
static void cmr2_commands(struct cgpu_info *icarus)
{
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(icarus->device_data);
if (info->speed_next_work) {
info->speed_next_work = false;
cmr2_command(icarus, ICARUS_CMR2_CMD_SPEED, info->cmr2_speed);
return;
}
if (info->flash_next_work) {
info->flash_next_work = false;
cmr2_command(icarus, ICARUS_CMR2_CMD_FLASH, ICARUS_CMR2_DATA_FLASH_ON);
cgsleep_ms(250);
cmr2_command(icarus, ICARUS_CMR2_CMD_FLASH, ICARUS_CMR2_DATA_FLASH_OFF);
cgsleep_ms(250);
cmr2_command(icarus, ICARUS_CMR2_CMD_FLASH, ICARUS_CMR2_DATA_FLASH_ON);
cgsleep_ms(250);
cmr2_command(icarus, ICARUS_CMR2_CMD_FLASH, ICARUS_CMR2_DATA_FLASH_OFF);
return;
}
}
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)
{ {
@ -1014,9 +1146,6 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
if (icarus->usbinfo.nodev) if (icarus->usbinfo.nodev)
return -1; return -1;
if (!info->initialised)
icarus_initialise(icarus, info->baud);
elapsed.tv_sec = elapsed.tv_usec = 0; elapsed.tv_sec = elapsed.tv_usec = 0;
memset((void *)(&workdata), 0, sizeof(workdata)); memset((void *)(&workdata), 0, sizeof(workdata));
@ -1025,6 +1154,9 @@ static int64_t icarus_scanhash(struct thr_info *thr, struct work *work,
rev((void *)(&(workdata.midstate)), ICARUS_MIDSTATE_SIZE); rev((void *)(&(workdata.midstate)), ICARUS_MIDSTATE_SIZE);
rev((void *)(&(workdata.work)), ICARUS_WORK_SIZE); rev((void *)(&(workdata.work)), ICARUS_WORK_SIZE);
if (info->speed_next_work || info->flash_next_work)
cmr2_commands(icarus);
// We only want results for the work we are about to send // We only want results for the work we are about to send
usb_buffer_clear(icarus); usb_buffer_clear(icarus);
@ -1245,17 +1377,80 @@ static struct api_data *icarus_api_stats(struct cgpu_info *cgpu)
return root; return root;
} }
static void icarus_statline_before(char *buf, size_t bufsiz, struct cgpu_info *cgpu)
{
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(cgpu->device_data);
if (info->ident == IDENT_CMR2 && info->cmr2_speed > 0)
tailsprintf(buf, bufsiz, "%5.1fMhz", (float)(info->cmr2_speed) * ICARUS_CMR2_SPEED_FACTOR);
else
tailsprintf(buf, bufsiz, " ");
tailsprintf(buf, bufsiz, " | ");
}
static void icarus_shutdown(__maybe_unused struct thr_info *thr) static void icarus_shutdown(__maybe_unused struct thr_info *thr)
{ {
// TODO: ? // TODO: ?
} }
static void icarus_identify(struct cgpu_info *cgpu)
{
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(cgpu->device_data);
if (info->ident == IDENT_CMR2)
info->flash_next_work = true;
}
static char *icarus_set(struct cgpu_info *cgpu, char *option, char *setting, char *replybuf)
{
struct ICARUS_INFO *info = (struct ICARUS_INFO *)(cgpu->device_data);
int val;
if (info->ident != IDENT_CMR2) {
strcpy(replybuf, "no set options available");
return replybuf;
}
if (strcasecmp(option, "help") == 0) {
sprintf(replybuf, "clock: range %d-%d",
ICARUS_CMR2_SPEED_MIN_INT, ICARUS_CMR2_SPEED_MAX_INT);
return replybuf;
}
if (strcasecmp(option, "clock") == 0) {
if (!setting || !*setting) {
sprintf(replybuf, "missing clock setting");
return replybuf;
}
val = atoi(setting);
if (val < ICARUS_CMR2_SPEED_MIN_INT || val > ICARUS_CMR2_SPEED_MAX_INT) {
sprintf(replybuf, "invalid clock: '%s' valid range %d-%d",
setting,
ICARUS_CMR2_SPEED_MIN_INT,
ICARUS_CMR2_SPEED_MAX_INT);
}
info->cmr2_speed = CMR2_INT_TO_SPEED(val);
info->speed_next_work = true;
return NULL;
}
sprintf(replybuf, "Unknown option: %s", option);
return replybuf;
}
struct device_drv icarus_drv = { struct device_drv icarus_drv = {
.drv_id = DRIVER_icarus, .drv_id = DRIVER_icarus,
.dname = "Icarus", .dname = "Icarus",
.name = "ICA", .name = "ICA",
.drv_detect = icarus_detect, .drv_detect = icarus_detect,
.get_api_stats = icarus_api_stats, .get_api_stats = icarus_api_stats,
.get_statline_before = icarus_statline_before,
.set_device = icarus_set,
.identify_device = icarus_identify,
.thread_prepare = icarus_prepare, .thread_prepare = icarus_prepare,
.scanhash = icarus_scanhash, .scanhash = icarus_scanhash,
.thread_shutdown = icarus_shutdown, .thread_shutdown = icarus_shutdown,

17
usbutils.c
Unescape View File

@ -2598,11 +2598,9 @@ out_noerrmsg:
if (NODEV(err)) { if (NODEV(err)) {
cg_ruwlock(&cgpu->usbinfo.devlock); cg_ruwlock(&cgpu->usbinfo.devlock);
release_cgpu(cgpu); release_cgpu(cgpu);
cg_dwlock(&cgpu->usbinfo.devlock); DEVWUNLOCK(cgpu, pstate);
} } else
DEVRUNLOCK(cgpu, pstate);
DEVRUNLOCK(cgpu, pstate);
return err; return err;
} }
@ -2700,10 +2698,9 @@ out_noerrmsg:
if (NODEV(err)) { if (NODEV(err)) {
cg_ruwlock(&cgpu->usbinfo.devlock); cg_ruwlock(&cgpu->usbinfo.devlock);
release_cgpu(cgpu); release_cgpu(cgpu);
cg_dwlock(&cgpu->usbinfo.devlock); DEVWUNLOCK(cgpu, pstate);
} } else
DEVRUNLOCK(cgpu, pstate);
DEVRUNLOCK(cgpu, pstate);
return err; return err;
} }
@ -3197,7 +3194,7 @@ void usb_cleanup(void)
cgsem_destroy(&usb_resource_sem); cgsem_destroy(&usb_resource_sem);
} }
#define DRIVER_COUNT_FOUND(X) if (strcasecmp(ptr, X##_drv.name) == 0) { \ #define DRIVER_COUNT_FOUND(X) if (X##_drv.name && strcasecmp(ptr, X##_drv.name) == 0) { \
drv_count[X##_drv.drv_id].limit = lim; \ drv_count[X##_drv.drv_id].limit = lim; \
found = true; \ found = true; \
} }

Write Preview
Loading…
Cancel
Save