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

update firmware and driver, create new cgminer fork

nfactor-troky
root 12 years ago committed by Con Kolivas
parent
88dc03d22a
commit
8ddd6b2a7d
1 changed files with 370 additions and 88 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. 458
      cgminer/driver-klondike.c

458
cgminer/driver-klondike.c
Unescape View File

@ -17,6 +17,7 @@
#include <strings.h> #include <strings.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
#include <math.h>
#include "config.h" #include "config.h"
@ -28,25 +29,29 @@
#include "miner.h" #include "miner.h"
#include "usbutils.h" #include "usbutils.h"
#define KLN "KLN"
#define K1 "K1" #define K1 "K1"
#define K16 "K16" #define K16 "K16"
#define K64 "K64" #define K64 "K64"
#define REPLY_BUFSIZE 64 #define MIDSTATE_BYTES 32
#define MERKLE_OFFSET 64
#define MERKLE_BYTES 12
struct device_drv klondike_drv; #define REPLY_BUFSIZE 32 // adequate for all types of replies
#define MAX_REPLY_COUNT 32 // more unhandled replies than this will result in data loss
#define REPLY_WAIT_TIME 100 // time to wait for a cmd polling it's reply
#define MAX_WORK_COUNT 4 // for now, must be binary multiple and match firmware
struct klondike_info { struct device_drv klondike_drv;
bool shutdown;
};
struct klondike_id { typedef struct klondike_id {
uint8_t version; uint8_t version;
uint8_t product[7];
uint32_t serial; uint32_t serial;
char product[8]; } IDENTITY;
};
struct klondike_status { typedef struct klondike_status {
uint8_t state; uint8_t state;
uint8_t chipcount; uint8_t chipcount;
uint8_t slavecount; uint8_t slavecount;
@ -54,60 +59,195 @@ struct klondike_status {
uint8_t workid; uint8_t workid;
uint8_t temp; uint8_t temp;
uint8_t fanspeed; uint8_t fanspeed;
uint8_t errorcount;
uint16_t hashcount; uint16_t hashcount;
uint16_t errorcount; uint16_t maxcount;
}; } WORKSTATUS;
struct kondike_cfg { 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 kondike_cfg {
uint16_t hashclock; uint16_t hashclock;
uint8_t temptarget; uint8_t temptarget;
uint8_t tempcritical; uint8_t tempcritical;
uint8_t fantarget; uint8_t fantarget;
uint8_t pad;
} WORKCFG;
typedef struct device_info {
uint32_t noncecount;
uint32_t nextworkid;
uint16_t lasthashcount;
uint64_t totalhashcount;
} 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;
}; };
static bool klondike_detect_one(struct libusb_device *dev, struct usb_find_devices *found) IDENTITY KlondikeID;
static char *SendCmdGetReply(struct cgpu_info *klncgpu, char Cmd, int device, int datalen, void *data)
{ {
struct cgpu_info *klninfo = calloc(1, sizeof(*klninfo)); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
char outbuf[64];
int retries = 10;
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) {
nmsleep(REPLY_WAIT_TIME);
while(*(klninfo->replies + chkreply*REPLY_BUFSIZE) != Cmd) {
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);
char replybuf[REPLY_BUFSIZE]; char replybuf[REPLY_BUFSIZE];
char devpath[20]; char devpath[20];
int attempts = 0; bool allok = false;
int sent, recd, err; int sent, recd, err;
int slaves, dev;
if (unlikely(!klninfo)) if (klncgpu->usbinfo.nodev)
quit(1, "Failed to calloc klninfo in klondike_detect_one"); return false;
char *reply = SendCmdGetReply(klncgpu, 'S', 0, 0, NULL);
if(reply != NULL && reply[0] == 'S' && reply[1] == 0) {
// todo: detect slavecount change and realloc space
slaves = ((WORKSTATUS *)(reply+2))->slavecount;
if(klninfo->status == NULL) {
applog(LOG_DEBUG, "Klondike initializing status 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");
// where does saved user cfg info come from?
// todo: set user cfg to devices
}
applog(LOG_DEBUG, "Klondike updating device status");
klninfo->drv = &klondike_drv; // device 0 is master and must exist
klninfo->deven = DEV_ENABLED; wr_lock(&(klninfo->stat_lock));
klninfo->threads = 1; klninfo->status[0] = *(WORKSTATUS *)(reply+2);
if (usb_init(klninfo, dev, found)) { // loop thru slaves and get status for each
for(dev = 1; dev < slaves; dev++) {
}
wr_unlock(&(klninfo->stat_lock));
allok = true;
}
return allok;
}
static bool klondike_detect_one(struct libusb_device *dev, struct usb_find_devices *found)
{
struct cgpu_info *klncgpu = calloc(1, sizeof(*klncgpu));
struct klondike_info *klninfo = NULL;
int attempts = 0;
if (unlikely(!klncgpu))
quit(1, "Failed to calloc klncgpu in klondike_detect_one");
sprintf(devpath, "%d:%d", (int)(klninfo->usbinfo.bus_number), (int)(klninfo->usbinfo.device_address)); klncgpu->drv = &klondike_drv;
while(attempts++ < 2) { klncgpu->deven = DEV_ENABLED;
klncgpu->threads = 1;
klninfo = calloc(1, sizeof(*klninfo));
if (unlikely(!klninfo))
quit(1, "Failed to calloc klninfo in klondke_detect_one");
// TODO: fix ... everywhere ...
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)) {
while(attempts++ < 3) {
char devpath[20], reply[32];
int sent, recd, err;
err = usb_write(klninfo, "I", 2, &sent, C_REQUESTIDENTIFY); 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) { if (err < 0 || sent != 2) {
applog(LOG_ERR, "%s detect (%s) send identify request failed (%d:%d)", klninfo->drv->dname, devpath, sent, err); applog(LOG_ERR, "%s (%s) detect write failed (%d:%d)", klncgpu->drv->dname, devpath, sent, err);
break;
} }
nmsleep(REPLY_WAIT_TIME*10);
err = usb_read(klninfo, replybuf, sizeof(replybuf), &recd, C_GETIDENTIFY); err = usb_read(klncgpu, reply, sizeof(IDENTITY)+2, &recd, C_GETRESULTS);
if (err < 0) { if (err < 0) {
applog(LOG_ERR, "%s detect (%s) error identify reply (%d:%d)", klninfo->drv->dname, devpath, recd, err); applog(LOG_ERR, "%s (%s) detect read failed (%d:%d)", klncgpu->drv->dname, devpath, recd, err);
} else if (recd < 1) { } else if (recd < 1) {
applog(LOG_ERR, "%s detect (%s) empty identify reply (%d)", klninfo->drv->dname, devpath, recd); applog(LOG_ERR, "%s (%s) detect empty reply (%d)", klncgpu->drv->dname, devpath, recd);
} else if (replybuf[0] == 'I' && replybuf[1] == 0) { } else if(reply[0] == 'I' && reply[1] == 0) {
applog(LOG_DEBUG, "%s (%s) identified as: '%s'", klninfo->drv->dname, devpath, klninfo->drv->name);
applog(LOG_DEBUG, "%s (%s) detect successful", klncgpu->drv->dname, devpath);
// do something with id info KlondikeID = *(IDENTITY *)(&reply[2]);
klncgpu->device_path = strdup(devpath);
update_usb_stats(klninfo); update_usb_stats(klncgpu);
if(!add_cgpu(klncgpu))
break;
applog(LOG_DEBUG, "Klondike cgpu added");
return true; return true;
} }
} }
usb_uninit(klninfo); usb_uninit(klncgpu);
} }
free(klninfo); free(klncgpu);
return false; return false;
} }
@ -116,112 +256,254 @@ static void klondike_detect(void)
usb_detect(&klondike_drv, klondike_detect_one); usb_detect(&klondike_drv, klondike_detect_one);
} }
static void klondike_identify(struct cgpu_info *klninfo) static void klondike_identify(struct cgpu_info *klncgpu)
{ {
struct klondike_info *k_info = (struct klondike_info *)(klninfo->device_file); 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 (x%08x)", result->nonce);
HASH_ITER(hh, klncgpu->queued_work, work, tmp) {
if (work->queued && (work->subid == (result->device*256 + result->workid))) {
// devflag is used to flag stale work
work->devflag = true;
wr_lock(&(klninfo->stat_lock));
klninfo->devinfo[result->device].noncecount++;
wr_unlock(&(klninfo->stat_lock));
result->nonce = le32toh(result->nonce - 0xC0);
applog(LOG_DEBUG, "Klondike SUBMIT NONCE (x%08x)", result->nonce);
submit_nonce(klncgpu->thr[0], work, result->nonce);
}
return;
}
applog(LOG_ERR, "%s%i:%d failed to find nonce work (x%08x) - can't be processed - ignored",
klncgpu->drv->name, klncgpu->device_id, result->device, result->nonce);
//inc_hw_errors(klncgpu->thr[0]);
} }
static bool klondike_thread_prepare(struct thr_info *thr) // thread to keep looking for replies
static void *klondike_get_replies(void *userdata)
{ {
struct cgpu_info *klninfo = thr->cgpu; struct cgpu_info *klncgpu = (struct cgpu_info *)userdata;
struct klondike_info *k_info = (struct klondike_info *)(klninfo->device_file); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
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_BUFSIZE-1, &recd, C_GETRESULTS);
if (err < 0 && err != -7)
applog(LOG_DEBUG, "%s (%s) error reply (%d:%d)", klncgpu->drv->dname, klncgpu->device_path, recd, err);
if (recd < 1)
continue;
else {
if(opt_log_level <= LOG_DEBUG) {
char *hexdata = bin2hex(replybuf+1, recd);
applog(LOG_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];
if(replybuf[0] == '=')
klondike_check_nonce(klncgpu, (WORKRESULT *)replybuf);
}
}
return NULL;
}
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);
struct timeval now;
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);
// init status data structures
nmsleep(500);
klondike_get_stats(klncgpu);
return true; return true;
} }
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 work");
for (dev = 0; dev <= klninfo->status->slavecount; dev++) {
char *reply = SendCmdGetReply(klncgpu, 'A', dev, 0, NULL);
if(reply != NULL && reply[0] == 'A' && reply[1] == dev) {
wr_lock(&(klninfo->stat_lock));
klninfo->status[dev] = *(WORKSTATUS *)(reply+2);
wr_unlock(&(klninfo->stat_lock));
}
}
}
static bool klondike_thread_init(struct thr_info *thr) static bool klondike_thread_init(struct thr_info *thr)
{ {
struct cgpu_info *klninfo = thr->cgpu; struct cgpu_info *klncgpu = thr->cgpu;
if (klninfo->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return false; return false;
//klondike_initialise(klninfo); klondike_flush_work(klncgpu);
return true; return true;
} }
static void klondike_flush_work(struct cgpu_info *klninfo)
{
struct klondike_info *k_info = (struct klondike_info *)(klninfo->device_file);
}
static void klondike_shutdown(struct thr_info *thr) static void klondike_shutdown(struct thr_info *thr)
{ {
struct cgpu_info *klninfo = thr->cgpu; struct cgpu_info *klncgpu = thr->cgpu;
struct klondike_info *k_info = (struct klondike_info *)(klninfo->device_file); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
klondike_flush_work(klninfo); klondike_flush_work(klncgpu);
k_info->shutdown = true; klninfo->shutdown = true;
} }
static void klondike_thread_enable(struct thr_info *thr) static void klondike_thread_enable(struct thr_info *thr)
{ {
struct cgpu_info *klninfo = thr->cgpu; struct cgpu_info *klncgpu = thr->cgpu;
if (klninfo->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return; return;
//klondike_initialise(bflsc); klondike_flush_work(klncgpu);
} }
static bool klondike_send_work(struct cgpu_info *klninfo, int dev, struct work *work) static bool klondike_send_work(struct cgpu_info *klncgpu, int dev, struct work *work)
{ {
struct klondike_info *k_info = (struct klondike_info *)(klninfo->device_file); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
WORKTASK data;
// Device is gone if (klncgpu->usbinfo.nodev)
if (klninfo->usbinfo.nodev)
return false; 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++);
work->subid = dev*256 + data.workid;
applog(LOG_DEBUG, "Klondike sending work (%d:x%02x)", dev, data.workid);
char *reply = SendCmdGetReply(klncgpu, 'W', dev, sizeof(data)-3, &data.workid);
if(reply != NULL && reply[0] == 'W' && reply[1] == dev) {
wr_lock(&(klninfo->stat_lock));
klninfo->status[dev] = *(WORKSTATUS *)(reply+2);
wr_unlock(&(klninfo->stat_lock));
return true;
}
return false;
} }
static bool klondike_queue_full(struct cgpu_info *klninfo) static bool klondike_queue_full(struct cgpu_info *klncgpu)
{ {
struct klondike_info *sc_info = (struct klondike_info *)(klninfo->device_file); 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) static int64_t klondike_scanwork(struct thr_info *thr)
{ {
struct cgpu_info *klninfo = thr->cgpu; struct cgpu_info *klncgpu = thr->cgpu;
struct klondike_info *sc_info = (struct klondike_info *)(klninfo->device_file); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
int64_t newhashcount = 0;
// Device is gone int dev;
if (klninfo->usbinfo.nodev)
if (klncgpu->usbinfo.nodev)
return -1; return -1;
restart_wait(500);
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)
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;
newhashcount += (newhashdev << 32) / klninfo->status[dev].maxcount;
}
rd_unlock(&(klninfo->stat_lock));
}
return newhashcount;
} }
static bool klondike_get_stats(struct cgpu_info *klninfo) static double convertKlnTemp(uint8_t temp)
{ {
struct klondike_info *k_info = (struct klondike_info *)(klninfo->device_file); return (double)1/((double)1/(25+273.15) + log((double)temp*1000/(256-temp)/2200)/3987) - 273.15;
bool allok = true;
int i;
// Device is gone
if (klninfo->usbinfo.nodev)
return false;
return allok;
} }
static void get_klondike_statline_before(char *buf, struct cgpu_info *klninfo) static void get_klondike_statline_before(char *buf, struct cgpu_info *klncgpu)
{ {
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
uint8_t temp = 0xFF;
int dev;
rd_lock(&(klninfo->stat_lock));
for (dev = 0; dev <= klninfo->status->slavecount; dev++) {
if (klninfo->status[dev].temp < temp)
temp = klninfo->status[dev].temp;
}
rd_unlock(&(klninfo->stat_lock));
tailsprintf(buf, " %3.0fC 1.2V | ", convertKlnTemp(temp));
} }
static struct api_data *klondike_api_stats(struct cgpu_info *klninfo) 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;
rd_lock(&(klninfo->stat_lock));
// todo: convert temp and make correct type float
//root = api_add_temp(root, "Temp", &(klninfo->status->temp), true);
// todo: convert hashclock value to MHz and correct type double
//root = api_add_freq(root, "Clock", &(klninfo->cfg->hashclock), true);
rd_unlock(&(klninfo->stat_lock));
} }
struct device_drv klondike_drv = { struct device_drv klondike_drv = {
.drv_id = DRIVER_KLONDIKE, .drv_id = DRIVER_KLONDIKE,
.dname = "Klondike", .dname = "Klondike",
.name = K16, .name = KLN,
.drv_detect = klondike_detect, .drv_detect = klondike_detect,
.get_api_stats = klondike_api_stats, .get_api_stats = klondike_api_stats,
.get_statline_before = get_klondike_statline_before, .get_statline_before = get_klondike_statline_before,

Write Preview
Loading…
Cancel
Save