mirror of https://github.com/GOSTSec/sgminer
kanoi
11 years ago
11 changed files with 825 additions and 16 deletions
@ -0,0 +1,719 @@ |
|||||||
|
/*
|
||||||
|
* Copyright 2013 Andrew Smith |
||||||
|
* Copyright 2013 Con Kolivas |
||||||
|
* Copyright 2013 Chris Savery |
||||||
|
* |
||||||
|
* 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 |
||||||
|
* Software Foundation; either version 3 of the License, or (at your option) |
||||||
|
* any later version. See COPYING for more details. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <float.h> |
||||||
|
#include <limits.h> |
||||||
|
#include <pthread.h> |
||||||
|
#include <stdint.h> |
||||||
|
#include <stdio.h> |
||||||
|
#include <strings.h> |
||||||
|
#include <sys/time.h> |
||||||
|
#include <unistd.h> |
||||||
|
#include <math.h> |
||||||
|
|
||||||
|
#include "config.h" |
||||||
|
|
||||||
|
#ifdef WIN32 |
||||||
|
#include <windows.h> |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "compat.h" |
||||||
|
#include "miner.h" |
||||||
|
#include "usbutils.h" |
||||||
|
|
||||||
|
#define K1 "K1" |
||||||
|
#define K16 "K16" |
||||||
|
#define K64 "K64" |
||||||
|
|
||||||
|
#define MIDSTATE_BYTES 32 |
||||||
|
#define MERKLE_OFFSET 64 |
||||||
|
#define MERKLE_BYTES 12 |
||||||
|
|
||||||
|
#define REPLY_SIZE 15 // adequate for all types of replies
|
||||||
|
#define REPLY_BUFSIZE 16 // reply + 1 byte to mark used
|
||||||
|
#define MAX_REPLY_COUNT 32 // more unhandled replies than this will result in data loss
|
||||||
|
#define REPLY_WAIT_TIME 100 // poll interval for a cmd waiting it's reply
|
||||||
|
#define CMD_REPLY_RETRIES 8 // how many retries for cmds
|
||||||
|
#define MAX_WORK_COUNT 4 // for now, must be binary multiple and match firmware
|
||||||
|
#define TACH_FACTOR 87890 // fan rpm divisor
|
||||||
|
|
||||||
|
struct device_drv klondike_drv; |
||||||
|
|
||||||
|
typedef struct klondike_id { |
||||||
|
uint8_t version; |
||||||
|
uint8_t product[7]; |
||||||
|
uint32_t serial; |
||||||
|
} IDENTITY; |
||||||
|
|
||||||
|
typedef struct klondike_status { |
||||||
|
uint8_t state; |
||||||
|
uint8_t chipcount; |
||||||
|
uint8_t slavecount; |
||||||
|
uint8_t workqc; |
||||||
|
uint8_t workid; |
||||||
|
uint8_t temp; |
||||||
|
uint8_t fanspeed; |
||||||
|
uint8_t errorcount; |
||||||
|
uint16_t hashcount; |
||||||
|
uint16_t maxcount; |
||||||
|
uint8_t noise; |
||||||
|
} WORKSTATUS; |
||||||
|
|
||||||
|
typedef struct _worktask { |
||||||
|
uint16_t pad1; |
||||||
|
uint8_t pad2; |
||||||
|
uint8_t workid; |
||||||
|
uint32_t midstate[8]; |
||||||
|
uint32_t merkle[3]; |
||||||
|
} WORKTASK; |
||||||
|
|
||||||
|
typedef struct _workresult { |
||||||
|
uint16_t pad; |
||||||
|
uint8_t device; |
||||||
|
uint8_t workid; |
||||||
|
uint32_t nonce; |
||||||
|
} WORKRESULT; |
||||||
|
|
||||||
|
typedef struct klondike_cfg { |
||||||
|
uint16_t hashclock; |
||||||
|
uint8_t temptarget; |
||||||
|
uint8_t tempcritical; |
||||||
|
uint8_t fantarget; |
||||||
|
uint8_t pad; |
||||||
|
} WORKCFG; |
||||||
|
|
||||||
|
typedef struct device_info { |
||||||
|
uint32_t noncecount; |
||||||
|
uint32_t nextworkid; |
||||||
|
uint16_t lasthashcount; |
||||||
|
uint64_t totalhashcount; |
||||||
|
uint32_t rangesize; |
||||||
|
uint32_t *chipstats; |
||||||
|
} DEVINFO; |
||||||
|
|
||||||
|
struct klondike_info { |
||||||
|
bool shutdown; |
||||||
|
pthread_rwlock_t stat_lock; |
||||||
|
struct thr_info replies_thr; |
||||||
|
WORKSTATUS *status; |
||||||
|
DEVINFO *devinfo; |
||||||
|
WORKCFG *cfg; |
||||||
|
char *replies; |
||||||
|
int nextreply; |
||||||
|
int noncecount; |
||||||
|
uint64_t hashcount; |
||||||
|
uint64_t errorcount; |
||||||
|
uint64_t noisecount; |
||||||
|
}; |
||||||
|
|
||||||
|
IDENTITY KlondikeID; |
||||||
|
|
||||||
|
static double cvtKlnToC(uint8_t temp) |
||||||
|
{ |
||||||
|
double Rt, stein, celsius; |
||||||
|
|
||||||
|
Rt = 1000.0 * 255.0 / (double)temp - 1000.0; |
||||||
|
|
||||||
|
stein = log(Rt / 2200.0) / 3987.0; |
||||||
|
|
||||||
|
stein += 1.0 / (double)(25.0 + 273.15); |
||||||
|
|
||||||
|
celsius = (1.0 / stein) - 273.15; |
||||||
|
|
||||||
|
return celsius; |
||||||
|
} |
||||||
|
|
||||||
|
static int cvtCToKln(double deg) |
||||||
|
{ |
||||||
|
double R = exp((1/(deg+273.15)-1/(273.15+25))*3987)*2200; |
||||||
|
return 256*R/(R+1000); |
||||||
|
} |
||||||
|
|
||||||
|
static char *SendCmdGetReply(struct cgpu_info *klncgpu, char Cmd, int device, int datalen, void *data) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
char outbuf[64]; |
||||||
|
int retries = CMD_REPLY_RETRIES; |
||||||
|
int chkreply = klninfo->nextreply; |
||||||
|
int sent, err; |
||||||
|
|
||||||
|
if (klncgpu->usbinfo.nodev) |
||||||
|
return NULL; |
||||||
|
|
||||||
|
outbuf[0] = Cmd; |
||||||
|
outbuf[1] = device; |
||||||
|
memcpy(outbuf+2, data, datalen); |
||||||
|
err = usb_write(klncgpu, outbuf, 2+datalen, &sent, C_REQUESTRESULTS); |
||||||
|
if (err < 0 || sent != 2+datalen) { |
||||||
|
applog(LOG_ERR, "%s (%s) Cmd:%c Dev:%d, write failed (%d:%d)", klncgpu->drv->dname, klncgpu->device_path, Cmd, device, sent, err); |
||||||
|
} |
||||||
|
while (retries-- > 0 && klninfo->shutdown == false) { |
||||||
|
cgsleep_ms(REPLY_WAIT_TIME); |
||||||
|
while (*(klninfo->replies + chkreply*REPLY_BUFSIZE) != Cmd || *(klninfo->replies + chkreply*REPLY_BUFSIZE + 2) != device) { |
||||||
|
if (++chkreply == MAX_REPLY_COUNT) |
||||||
|
chkreply = 0; |
||||||
|
if (chkreply == klninfo->nextreply) |
||||||
|
break; |
||||||
|
} |
||||||
|
if (chkreply == klninfo->nextreply) |
||||||
|
continue; |
||||||
|
*(klninfo->replies + chkreply*REPLY_BUFSIZE) = '!'; // mark to prevent re-use
|
||||||
|
return klninfo->replies + chkreply*REPLY_BUFSIZE + 1; |
||||||
|
} |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_get_stats(struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
int slaves, dev; |
||||||
|
|
||||||
|
if (klncgpu->usbinfo.nodev || klninfo->status == NULL) |
||||||
|
return false; |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike getting status"); |
||||||
|
slaves = klninfo->status[0].slavecount; |
||||||
|
|
||||||
|
// loop thru devices and get status for each
|
||||||
|
wr_lock(&(klninfo->stat_lock)); |
||||||
|
for (dev = 0; dev <= slaves; dev++) { |
||||||
|
char *reply = SendCmdGetReply(klncgpu, 'S', dev, 0, NULL); |
||||||
|
if (reply != NULL) |
||||||
|
memcpy((void *)(&(klninfo->status[dev])), reply+2, sizeof(klninfo->status[dev])); |
||||||
|
} |
||||||
|
wr_unlock(&(klninfo->stat_lock)); |
||||||
|
|
||||||
|
// todo: detect slavecount change and realloc space
|
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_init(struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
int slaves, dev; |
||||||
|
|
||||||
|
char *reply = SendCmdGetReply(klncgpu, 'S', 0, 0, NULL); |
||||||
|
if (reply == NULL) |
||||||
|
return false; |
||||||
|
|
||||||
|
slaves = ((WORKSTATUS *)(reply+2))->slavecount; |
||||||
|
if (klninfo->status == NULL) { |
||||||
|
applog(LOG_DEBUG, "Klondike initializing data"); |
||||||
|
|
||||||
|
// alloc space for status, devinfo and cfg for master and slaves
|
||||||
|
klninfo->status = calloc(slaves+1, sizeof(WORKSTATUS)); |
||||||
|
if (unlikely(!klninfo->status)) |
||||||
|
quit(1, "Failed to calloc status array in klondke_get_stats"); |
||||||
|
klninfo->devinfo = calloc(slaves+1, sizeof(DEVINFO)); |
||||||
|
if (unlikely(!klninfo->devinfo)) |
||||||
|
quit(1, "Failed to calloc devinfo array in klondke_get_stats"); |
||||||
|
klninfo->cfg = calloc(slaves+1, sizeof(WORKCFG)); |
||||||
|
if (unlikely(!klninfo->cfg)) |
||||||
|
quit(1, "Failed to calloc cfg array in klondke_get_stats"); |
||||||
|
} |
||||||
|
|
||||||
|
WORKCFG cfgset = { 0,0,0,0,0 }; // zero init triggers read back only
|
||||||
|
double temp1, temp2; |
||||||
|
int size = 2; |
||||||
|
|
||||||
|
if (opt_klondike_options != NULL) { // boundaries are checked by device, with valid values returned
|
||||||
|
sscanf(opt_klondike_options, "%hu:%lf:%lf:%hhu", &cfgset.hashclock, &temp1, &temp2, &cfgset.fantarget); |
||||||
|
cfgset.temptarget = cvtCToKln(temp1); |
||||||
|
cfgset.tempcritical = cvtCToKln(temp2); |
||||||
|
cfgset.fantarget = (int)255*cfgset.fantarget/100; |
||||||
|
size = sizeof(cfgset); |
||||||
|
} |
||||||
|
|
||||||
|
for (dev = 0; dev <= slaves; dev++) { |
||||||
|
char *reply = SendCmdGetReply(klncgpu, 'C', dev, size, &cfgset); |
||||||
|
if (reply != NULL) { |
||||||
|
klninfo->cfg[dev] = *(WORKCFG *)(reply+2); |
||||||
|
applog(LOG_NOTICE, "Klondike config (%d: Clk: %d, T:%.0lf, C:%.0lf, F:%d)", |
||||||
|
dev, klninfo->cfg[dev].hashclock, |
||||||
|
cvtKlnToC(klninfo->cfg[dev].temptarget), |
||||||
|
cvtKlnToC(klninfo->cfg[dev].tempcritical), |
||||||
|
(int)100*klninfo->cfg[dev].fantarget/256); |
||||||
|
} |
||||||
|
} |
||||||
|
klondike_get_stats(klncgpu); |
||||||
|
for (dev = 0; dev <= slaves; dev++) { |
||||||
|
klninfo->devinfo[dev].rangesize = ((uint64_t)1<<32) / klninfo->status[dev].chipcount; |
||||||
|
klninfo->devinfo[dev].chipstats = calloc(klninfo->status[dev].chipcount*2 , sizeof(uint32_t)); |
||||||
|
} |
||||||
|
|
||||||
|
SendCmdGetReply(klncgpu, 'E', 0, 1, "1"); |
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_detect_one(struct libusb_device *dev, struct usb_find_devices *found) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = usb_alloc_cgpu(&klondike_drv, 1); |
||||||
|
struct klondike_info *klninfo = NULL; |
||||||
|
|
||||||
|
if (unlikely(!klncgpu)) |
||||||
|
quit(1, "Failed to calloc klncgpu in klondike_detect_one"); |
||||||
|
|
||||||
|
klninfo = calloc(1, sizeof(*klninfo)); |
||||||
|
if (unlikely(!klninfo)) |
||||||
|
quit(1, "Failed to calloc klninfo in klondke_detect_one"); |
||||||
|
klncgpu->device_data = (FILE *)klninfo; |
||||||
|
|
||||||
|
klninfo->replies = calloc(MAX_REPLY_COUNT, REPLY_BUFSIZE); |
||||||
|
if (unlikely(!klninfo->replies)) |
||||||
|
quit(1, "Failed to calloc replies buffer in klondke_detect_one"); |
||||||
|
klninfo->nextreply = 0; |
||||||
|
|
||||||
|
if (usb_init(klncgpu, dev, found)) { |
||||||
|
int attempts = 0; |
||||||
|
while (attempts++ < 3) { |
||||||
|
char devpath[20], reply[REPLY_SIZE]; |
||||||
|
int sent, recd, err; |
||||||
|
|
||||||
|
sprintf(devpath, "%d:%d", (int)(klncgpu->usbinfo.bus_number), (int)(klncgpu->usbinfo.device_address)); |
||||||
|
err = usb_write(klncgpu, "I", 2, &sent, C_REQUESTRESULTS); |
||||||
|
if (err < 0 || sent != 2) { |
||||||
|
applog(LOG_ERR, "%s (%s) detect write failed (%d:%d)", klncgpu->drv->dname, devpath, sent, err); |
||||||
|
} |
||||||
|
cgsleep_ms(REPLY_WAIT_TIME*10); |
||||||
|
err = usb_read(klncgpu, reply, REPLY_SIZE, &recd, C_GETRESULTS); |
||||||
|
if (err < 0) { |
||||||
|
applog(LOG_ERR, "%s (%s) detect read failed (%d:%d)", klncgpu->drv->dname, devpath, recd, err); |
||||||
|
} else if (recd < 1) { |
||||||
|
applog(LOG_ERR, "%s (%s) detect empty reply (%d)", klncgpu->drv->dname, devpath, recd); |
||||||
|
} else if (reply[0] == 'I' && reply[1] == 0) { |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "%s (%s) detect successful", klncgpu->drv->dname, devpath); |
||||||
|
KlondikeID = *(IDENTITY *)(&reply[2]); |
||||||
|
klncgpu->device_path = strdup(devpath); |
||||||
|
update_usb_stats(klncgpu); |
||||||
|
if (!add_cgpu(klncgpu)) |
||||||
|
break; |
||||||
|
applog(LOG_DEBUG, "Klondike cgpu added"); |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
usb_uninit(klncgpu); |
||||||
|
} |
||||||
|
free(klninfo->replies); |
||||||
|
free(klncgpu); |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
static void klondike_detect(bool __maybe_unused hotplug) |
||||||
|
{ |
||||||
|
usb_detect(&klondike_drv, klondike_detect_one); |
||||||
|
} |
||||||
|
|
||||||
|
static void klondike_identify(__maybe_unused struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
//SendCmdGetReply(klncgpu, 'I', 0, 0, NULL);
|
||||||
|
} |
||||||
|
|
||||||
|
static void klondike_check_nonce(struct cgpu_info *klncgpu, WORKRESULT *result) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
struct work *work, *tmp; |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike FOUND NONCE (%02x:%08x)", result->workid, result->nonce); |
||||||
|
|
||||||
|
HASH_ITER(hh, klncgpu->queued_work, work, tmp) { |
||||||
|
if (work->queued && (work->subid == (result->device*256 + result->workid))) { |
||||||
|
|
||||||
|
wr_lock(&(klninfo->stat_lock)); |
||||||
|
klninfo->devinfo[result->device].noncecount++; |
||||||
|
klninfo->noncecount++; |
||||||
|
wr_unlock(&(klninfo->stat_lock)); |
||||||
|
|
||||||
|
result->nonce = le32toh(result->nonce - 0xC0); |
||||||
|
applog(LOG_DEBUG, "Klondike SUBMIT NONCE (%02x:%08x)", result->workid, result->nonce); |
||||||
|
bool ok = submit_nonce(klncgpu->thr[0], work, result->nonce); |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike chip stats %d, %08x, %d, %d", result->device, result->nonce, klninfo->devinfo[result->device].rangesize, klninfo->status[result->device].chipcount); |
||||||
|
klninfo->devinfo[result->device].chipstats[(result->nonce / klninfo->devinfo[result->device].rangesize) + (ok ? 0 : klninfo->status[result->device].chipcount)]++; |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
applog(LOG_ERR, "%s%i:%d unknown work (%02x:%08x) - ignored", |
||||||
|
klncgpu->drv->name, klncgpu->device_id, result->device, result->workid, result->nonce); |
||||||
|
//inc_hw_errors(klncgpu->thr[0]);
|
||||||
|
} |
||||||
|
|
||||||
|
// Change this to LOG_WARNING if you wish to always see the replies
|
||||||
|
#define READ_DEBUG LOG_DEBUG |
||||||
|
|
||||||
|
// thread to keep looking for replies
|
||||||
|
static void *klondike_get_replies(void *userdata) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = (struct cgpu_info *)userdata; |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
struct klondike_status *ks; |
||||||
|
struct _workresult *wr; |
||||||
|
struct klondike_cfg *kc; |
||||||
|
struct klondike_id *ki; |
||||||
|
char *replybuf; |
||||||
|
int err, recd; |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike listening for replies"); |
||||||
|
|
||||||
|
while (klninfo->shutdown == false) { |
||||||
|
if (klncgpu->usbinfo.nodev) |
||||||
|
return NULL; |
||||||
|
|
||||||
|
replybuf = klninfo->replies + klninfo->nextreply * REPLY_BUFSIZE; |
||||||
|
replybuf[0] = 0; |
||||||
|
|
||||||
|
err = usb_read(klncgpu, replybuf+1, REPLY_SIZE, &recd, C_GETRESULTS); |
||||||
|
if (!err && recd == REPLY_SIZE) { |
||||||
|
if (opt_log_level <= READ_DEBUG) { |
||||||
|
char *hexdata = bin2hex((unsigned char *)(replybuf+1), recd); |
||||||
|
applog(READ_DEBUG, "%s (%s) reply [%s:%s]", klncgpu->drv->dname, klncgpu->device_path, replybuf+1, hexdata); |
||||||
|
free(hexdata); |
||||||
|
} |
||||||
|
if (++klninfo->nextreply == MAX_REPLY_COUNT) |
||||||
|
klninfo->nextreply = 0; |
||||||
|
|
||||||
|
replybuf[0] = replybuf[1]; |
||||||
|
switch (replybuf[0]) { |
||||||
|
case '=': |
||||||
|
wr = (struct _workresult *)(replybuf+1); |
||||||
|
klondike_check_nonce(klncgpu, (WORKRESULT *)replybuf); |
||||||
|
applog(READ_DEBUG, |
||||||
|
"%s (%s) reply: work [%c] device=%d workid=%d" |
||||||
|
" nonce=0x%08x", |
||||||
|
klncgpu->drv->dname, klncgpu->device_path, |
||||||
|
*(replybuf+1), |
||||||
|
(int)(wr->device), |
||||||
|
(int)(wr->workid), |
||||||
|
(unsigned int)(wr->nonce)); |
||||||
|
break; |
||||||
|
case 'S': |
||||||
|
case 'W': |
||||||
|
case 'A': |
||||||
|
case 'E': |
||||||
|
ks = (struct klondike_status *)(replybuf+1); |
||||||
|
wr_lock(&(klninfo->stat_lock)); |
||||||
|
klninfo->errorcount += ks->errorcount; |
||||||
|
klninfo->noisecount += ks->noise; |
||||||
|
wr_unlock(&(klninfo->stat_lock)); |
||||||
|
applog(READ_DEBUG, |
||||||
|
"%s (%s) reply: status [%c] chips=%d slaves=%d" |
||||||
|
" workcq=%d workid=%d temp=%d fan=%d errors=%d" |
||||||
|
" hashes=%d max=%d noise=%d", |
||||||
|
klncgpu->drv->dname, klncgpu->device_path, |
||||||
|
*(replybuf+1), |
||||||
|
(int)(ks->chipcount), |
||||||
|
(int)(ks->slavecount), |
||||||
|
(int)(ks->workqc), |
||||||
|
(int)(ks->workid), |
||||||
|
(int)(ks->temp), |
||||||
|
(int)(ks->fanspeed), |
||||||
|
(int)(ks->errorcount), |
||||||
|
(int)(ks->hashcount), |
||||||
|
(int)(ks->maxcount), |
||||||
|
(int)(ks->noise)); |
||||||
|
break; |
||||||
|
case 'C': |
||||||
|
kc = (struct klondike_cfg *)(replybuf+2); |
||||||
|
applog(READ_DEBUG, |
||||||
|
"%s (%s) reply: config [%c] clock=%d temptarget=%d" |
||||||
|
" tempcrit=%d fan=%d", |
||||||
|
klncgpu->drv->dname, klncgpu->device_path, |
||||||
|
*(replybuf+1), |
||||||
|
(int)(kc->hashclock), |
||||||
|
(int)(kc->temptarget), |
||||||
|
(int)(kc->tempcritical), |
||||||
|
(int)(kc->fantarget)); |
||||||
|
break; |
||||||
|
case 'I': |
||||||
|
ki = (struct klondike_id *)(replybuf+2); |
||||||
|
applog(READ_DEBUG, |
||||||
|
"%s (%s) reply: info [%c] version=0x%02x prod=%.7s" |
||||||
|
" serial=0x%08x", |
||||||
|
klncgpu->drv->dname, klncgpu->device_path, |
||||||
|
*(replybuf+1), |
||||||
|
(int)(ki->version), |
||||||
|
ki->product, |
||||||
|
(unsigned int)(ki->serial)); |
||||||
|
break; |
||||||
|
default: |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
static void klondike_flush_work(struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
int dev; |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike flushing work"); |
||||||
|
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { |
||||||
|
char *reply = SendCmdGetReply(klncgpu, 'A', dev, 0, NULL); |
||||||
|
if (reply != NULL) { |
||||||
|
wr_lock(&(klninfo->stat_lock)); |
||||||
|
klninfo->status[dev] = *(WORKSTATUS *)(reply+2); |
||||||
|
wr_unlock(&(klninfo->stat_lock)); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_thread_prepare(struct thr_info *thr) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = thr->cgpu; |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
|
||||||
|
if (thr_info_create(&(klninfo->replies_thr), NULL, klondike_get_replies, (void *)klncgpu)) { |
||||||
|
applog(LOG_ERR, "%s%i: thread create failed", klncgpu->drv->name, klncgpu->device_id); |
||||||
|
return false; |
||||||
|
} |
||||||
|
pthread_detach(klninfo->replies_thr.pth); |
||||||
|
|
||||||
|
// let the listening get started
|
||||||
|
cgsleep_ms(100); |
||||||
|
|
||||||
|
return klondike_init(klncgpu); |
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_thread_init(struct thr_info *thr) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = thr->cgpu; |
||||||
|
|
||||||
|
if (klncgpu->usbinfo.nodev) |
||||||
|
return false; |
||||||
|
|
||||||
|
klondike_flush_work(klncgpu); |
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
static void klondike_shutdown(struct thr_info *thr) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = thr->cgpu; |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
int dev; |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike shutting down work"); |
||||||
|
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { |
||||||
|
SendCmdGetReply(klncgpu, 'E', dev, 1, "0"); |
||||||
|
} |
||||||
|
klncgpu->shutdown = klninfo->shutdown = true; |
||||||
|
} |
||||||
|
|
||||||
|
static void klondike_thread_enable(struct thr_info *thr) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = thr->cgpu; |
||||||
|
|
||||||
|
if (klncgpu->usbinfo.nodev) |
||||||
|
return; |
||||||
|
|
||||||
|
//SendCmdGetReply(klncgpu, 'E', 0, 1, "0");
|
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_send_work(struct cgpu_info *klncgpu, int dev, struct work *work) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
struct work *tmp; |
||||||
|
WORKTASK data; |
||||||
|
|
||||||
|
if (klncgpu->usbinfo.nodev) |
||||||
|
return false; |
||||||
|
|
||||||
|
memcpy(data.midstate, work->midstate, MIDSTATE_BYTES); |
||||||
|
memcpy(data.merkle, work->data + MERKLE_OFFSET, MERKLE_BYTES); |
||||||
|
data.workid = (uint8_t)(klninfo->devinfo[dev].nextworkid++ & 0xFF); |
||||||
|
work->subid = dev*256 + data.workid; |
||||||
|
|
||||||
|
if (opt_log_level <= LOG_DEBUG) { |
||||||
|
char *hexdata = bin2hex(&data.workid, sizeof(data)-3); |
||||||
|
applog(LOG_DEBUG, "WORKDATA: %s", hexdata); |
||||||
|
free(hexdata); |
||||||
|
} |
||||||
|
|
||||||
|
applog(LOG_DEBUG, "Klondike sending work (%d:%02x)", dev, data.workid); |
||||||
|
char *reply = SendCmdGetReply(klncgpu, 'W', dev, sizeof(data)-3, &data.workid); |
||||||
|
if (reply != NULL) { |
||||||
|
wr_lock(&(klninfo->stat_lock)); |
||||||
|
klninfo->status[dev] = *(WORKSTATUS *)(reply+2); |
||||||
|
wr_unlock(&(klninfo->stat_lock)); |
||||||
|
|
||||||
|
// remove old work
|
||||||
|
HASH_ITER(hh, klncgpu->queued_work, work, tmp) { |
||||||
|
if (work->queued && (work->subid == (int)(dev*256 + ((klninfo->devinfo[dev].nextworkid-2*MAX_WORK_COUNT) & 0xFF)))) |
||||||
|
work_completed(klncgpu, work); |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
static bool klondike_queue_full(struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
struct work *work = NULL; |
||||||
|
int dev, queued; |
||||||
|
|
||||||
|
for (queued = 0; queued < MAX_WORK_COUNT-1; queued++) |
||||||
|
for (dev = 0; dev <= klninfo->status->slavecount; dev++) |
||||||
|
if (klninfo->status[dev].workqc <= queued) { |
||||||
|
if (!work) |
||||||
|
work = get_queued(klncgpu); |
||||||
|
if (unlikely(!work)) |
||||||
|
return false; |
||||||
|
if (klondike_send_work(klncgpu, dev, work)) { |
||||||
|
work = NULL; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
static int64_t klondike_scanwork(struct thr_info *thr) |
||||||
|
{ |
||||||
|
struct cgpu_info *klncgpu = thr->cgpu; |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
int64_t newhashcount = 0; |
||||||
|
int dev; |
||||||
|
|
||||||
|
if (klncgpu->usbinfo.nodev) |
||||||
|
return -1; |
||||||
|
|
||||||
|
restart_wait(thr, 200); |
||||||
|
if (klninfo->status != NULL) { |
||||||
|
rd_lock(&(klninfo->stat_lock)); |
||||||
|
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { |
||||||
|
uint64_t newhashdev = 0; |
||||||
|
if (klninfo->devinfo[dev].lasthashcount > klninfo->status[dev].hashcount) // todo: chg this to check workid for wrapped instead
|
||||||
|
newhashdev += klninfo->status[dev].maxcount; // hash counter wrapped
|
||||||
|
newhashdev += klninfo->status[dev].hashcount - klninfo->devinfo[dev].lasthashcount; |
||||||
|
klninfo->devinfo[dev].lasthashcount = klninfo->status[dev].hashcount; |
||||||
|
if (klninfo->status[dev].maxcount != 0) |
||||||
|
klninfo->hashcount += (newhashdev << 32) / klninfo->status[dev].maxcount; |
||||||
|
|
||||||
|
// todo: check stats for critical conditions
|
||||||
|
} |
||||||
|
newhashcount += 0xffffffffull * (uint64_t)klninfo->noncecount; |
||||||
|
klninfo->noncecount = 0; |
||||||
|
rd_unlock(&(klninfo->stat_lock)); |
||||||
|
} |
||||||
|
return newhashcount; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
static void get_klondike_statline_before(char *buf, size_t siz, struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
uint8_t temp = 0xFF; |
||||||
|
uint16_t fan = 0; |
||||||
|
int dev; |
||||||
|
|
||||||
|
if (klninfo->status == NULL) |
||||||
|
return; |
||||||
|
|
||||||
|
rd_lock(&(klninfo->stat_lock)); |
||||||
|
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { |
||||||
|
if (klninfo->status[dev].temp < temp) |
||||||
|
temp = klninfo->status[dev].temp; |
||||||
|
fan += klninfo->cfg[dev].fantarget; |
||||||
|
} |
||||||
|
fan /= klninfo->status->slavecount+1; |
||||||
|
rd_unlock(&(klninfo->stat_lock)); |
||||||
|
|
||||||
|
tailsprintf(buf, siz, " %3.0fC %3d%% | ", cvtKlnToC(temp), fan*100/255); |
||||||
|
} |
||||||
|
|
||||||
|
static struct api_data *klondike_api_stats(struct cgpu_info *klncgpu) |
||||||
|
{ |
||||||
|
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); |
||||||
|
struct api_data *root = NULL; |
||||||
|
char buf[32]; |
||||||
|
int dev; |
||||||
|
|
||||||
|
if (klninfo->status == NULL) |
||||||
|
return NULL; |
||||||
|
|
||||||
|
rd_lock(&(klninfo->stat_lock)); |
||||||
|
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { |
||||||
|
|
||||||
|
float fTemp = cvtKlnToC(klninfo->status[dev].temp); |
||||||
|
sprintf(buf, "Temp %d", dev); |
||||||
|
root = api_add_temp(root, buf, &fTemp, true); |
||||||
|
|
||||||
|
double dClk = (double)klninfo->cfg[dev].hashclock; |
||||||
|
sprintf(buf, "Clock %d", dev); |
||||||
|
root = api_add_freq(root, buf, &dClk, true); |
||||||
|
|
||||||
|
unsigned int iFan = (unsigned int)100 * klninfo->cfg[dev].fantarget / 255; |
||||||
|
sprintf(buf, "Fan Percent %d", dev); |
||||||
|
root = api_add_int(root, buf, (int *)(&iFan), true); |
||||||
|
|
||||||
|
iFan = 0; |
||||||
|
if (klninfo->status[dev].fanspeed > 0) |
||||||
|
iFan = (unsigned int)TACH_FACTOR / klninfo->status[dev].fanspeed; |
||||||
|
sprintf(buf, "Fan RPM %d", dev); |
||||||
|
root = api_add_int(root, buf, (int *)(&iFan), true); |
||||||
|
|
||||||
|
if (klninfo->devinfo[dev].chipstats != NULL) { |
||||||
|
char data[2048]; |
||||||
|
char one[32]; |
||||||
|
int n; |
||||||
|
|
||||||
|
sprintf(buf, "Nonces / Chip %d", dev); |
||||||
|
data[0] = '\0'; |
||||||
|
for (n = 0; n < klninfo->status[dev].chipcount; n++) { |
||||||
|
snprintf(one, sizeof(one), "%07d ", klninfo->devinfo[dev].chipstats[n]); |
||||||
|
strcat(data, one); |
||||||
|
} |
||||||
|
root = api_add_string(root, buf, data, true); |
||||||
|
|
||||||
|
sprintf(buf, "Errors / Chip %d", dev); |
||||||
|
data[0] = '\0'; |
||||||
|
for (n = 0; n < klninfo->status[dev].chipcount; n++) { |
||||||
|
snprintf(one, sizeof(one), "%07d ", klninfo->devinfo[dev].chipstats[n + klninfo->status[dev].chipcount]); |
||||||
|
strcat(data, one); |
||||||
|
} |
||||||
|
root = api_add_string(root, buf, data, true); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
root = api_add_uint64(root, "Hash Count", &(klninfo->hashcount), true); |
||||||
|
root = api_add_uint64(root, "Error Count", &(klninfo->errorcount), true); |
||||||
|
root = api_add_uint64(root, "Noise Count", &(klninfo->noisecount), true); |
||||||
|
|
||||||
|
rd_unlock(&(klninfo->stat_lock)); |
||||||
|
|
||||||
|
return root; |
||||||
|
} |
||||||
|
|
||||||
|
struct device_drv klondike_drv = { |
||||||
|
.drv_id = DRIVER_klondike, |
||||||
|
.dname = "Klondike", |
||||||
|
.name = "KLN", |
||||||
|
.drv_detect = klondike_detect, |
||||||
|
.get_api_stats = klondike_api_stats, |
||||||
|
.get_statline_before = get_klondike_statline_before, |
||||||
|
.get_stats = klondike_get_stats, |
||||||
|
.identify_device = klondike_identify, |
||||||
|
.thread_prepare = klondike_thread_prepare, |
||||||
|
.thread_init = klondike_thread_init, |
||||||
|
.hash_work = hash_queued_work, |
||||||
|
.scanwork = klondike_scanwork, |
||||||
|
.queue_full = klondike_queue_full, |
||||||
|
.flush_work = klondike_flush_work, |
||||||
|
.thread_shutdown = klondike_shutdown, |
||||||
|
.thread_enable = klondike_thread_enable |
||||||
|
}; |
||||||
Loading…
Reference in new issue