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

Move to consistent function names hfa_ for hashfast driver.

nfactor-troky
Con Kolivas 11 years ago
parent
8218ba2f06
commit
51548c6134
1 changed files with 63 additions and 65 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. 128
      driver-hashfast.c

128
driver-hashfast.c
Unescape View File

@ -25,7 +25,7 @@
static unsigned char crc8_table[256]; /* CRC-8 table */ static unsigned char crc8_table[256]; /* CRC-8 table */
static void hf_init_crc8(void) static void hfa_init_crc8(void)
{ {
int i,j; int i,j;
unsigned char crc; unsigned char crc;
@ -38,7 +38,7 @@ static void hf_init_crc8(void)
} }
} }
static unsigned char __maybe_unused hf_crc8(unsigned char *h) static unsigned char hfa_crc8(unsigned char *h)
{ {
int i; int i;
unsigned char crc; unsigned char crc;
@ -50,7 +50,7 @@ static unsigned char __maybe_unused hf_crc8(unsigned char *h)
return crc; return crc;
} }
struct hf_cmd { struct hfa_cmd {
int cmd; int cmd;
char *cmd_name; char *cmd_name;
enum usb_cmds usb_cmd; enum usb_cmds usb_cmd;
@ -59,7 +59,7 @@ struct hf_cmd {
/* Entries in this array need to align with the actual op values specified /* Entries in this array need to align with the actual op values specified
* in hf_protocol.h */ * in hf_protocol.h */
#define C_NULL C_MAX #define C_NULL C_MAX
static const struct hf_cmd hf_cmds[] = { static const struct hfa_cmd hfa_cmds[] = {
{OP_NULL, "OP_NULL", C_NULL}, // 0 {OP_NULL, "OP_NULL", C_NULL}, // 0
{OP_ROOT, "OP_ROOT", C_NULL}, {OP_ROOT, "OP_ROOT", C_NULL},
{OP_RESET, "OP_RESET", C_HF_RESET}, {OP_RESET, "OP_RESET", C_HF_RESET},
@ -98,8 +98,8 @@ static const struct hf_cmd hf_cmds[] = {
/* Send an arbitrary frame, consisting of an 8 byte header and an optional /* Send an arbitrary frame, consisting of an 8 byte header and an optional
* packet body. */ * packet body. */
static bool hashfast_send_frame(struct cgpu_info *hashfast, uint8_t opcode, static bool hfa_send_frame(struct cgpu_info *hashfast, uint8_t opcode, uint16_t hdata,
uint16_t hdata, uint8_t *data, int len) uint8_t *data, int len)
{ {
int tx_length, ret, amount, id = hashfast->device_id; int tx_length, ret, amount, id = hashfast->device_id;
uint8_t packet[256]; uint8_t packet[256];
@ -111,39 +111,37 @@ static bool hashfast_send_frame(struct cgpu_info *hashfast, uint8_t opcode,
p->core_address = 0; p->core_address = 0;
p->hdata = htole16(hdata); p->hdata = htole16(hdata);
p->data_length = len / 4; p->data_length = len / 4;
p->crc8 = hf_crc8(packet); p->crc8 = hfa_crc8(packet);
if (len) if (len)
memcpy(&packet[sizeof(struct hf_header)], data, len); memcpy(&packet[sizeof(struct hf_header)], data, len);
tx_length = sizeof(struct hf_header) + len; tx_length = sizeof(struct hf_header) + len;
ret = usb_write(hashfast, (char *)packet, tx_length, &amount, ret = usb_write(hashfast, (char *)packet, tx_length, &amount,
hf_cmds[opcode].usb_cmd); hfa_cmds[opcode].usb_cmd);
if (unlikely(ret < 0 || amount != tx_length)) { if (unlikely(ret < 0 || amount != tx_length)) {
applog(LOG_ERR, "HFA %d: hashfast_send_frame: USB Send error, ret %d amount %d vs. tx_length %d", applog(LOG_ERR, "HFA %d: hfa_send_frame: USB Send error, ret %d amount %d vs. tx_length %d",
id, ret, amount, tx_length); id, ret, amount, tx_length);
return false; return false;
} }
return true; return true;
} }
static bool hashfast_send_header(struct cgpu_info *hashfast, struct hf_header *h, static bool hfa_send_header(struct cgpu_info *hashfast, struct hf_header *h, int cmd)
int cmd)
{ {
int amount, ret, len; int amount, ret, len;
len = sizeof(*h); len = sizeof(*h);
ret = usb_write(hashfast, (char *)h, len, &amount, hf_cmds[cmd].usb_cmd); ret = usb_write(hashfast, (char *)h, len, &amount, hfa_cmds[cmd].usb_cmd);
if (ret < 0 || amount != len) { if (ret < 0 || amount != len) {
applog(LOG_WARNING, "HFA%d: send_header: %s USB Send error, ret %d amount %d vs. length %d", applog(LOG_WARNING, "HFA%d: send_header: %s USB Send error, ret %d amount %d vs. length %d",
hashfast->device_id, hf_cmds[cmd].cmd_name, ret, amount, len); hashfast->device_id, hfa_cmds[cmd].cmd_name, ret, amount, len);
return false; return false;
} }
return true; return true;
} }
static bool hashfast_get_header(struct cgpu_info *hashfast, struct hf_header *h, static bool hfa_get_header(struct cgpu_info *hashfast, struct hf_header *h, uint8_t *computed_crc)
uint8_t *computed_crc)
{ {
int amount, ret, orig_len, len, ofs = 0, reads = 0; int amount, ret, orig_len, len, ofs = 0, reads = 0;
char buf[512]; char buf[512];
@ -168,12 +166,12 @@ static bool hashfast_get_header(struct cgpu_info *hashfast, struct hf_header *h,
} while (len); } while (len);
memcpy(h, header, orig_len); memcpy(h, header, orig_len);
*computed_crc = hf_crc8((uint8_t *)h); *computed_crc = hfa_crc8((uint8_t *)h);
return true; return true;
} }
static bool hashfast_get_data(struct cgpu_info *hashfast, char *buf, int len4) static bool hfa_get_data(struct cgpu_info *hashfast, char *buf, int len4)
{ {
int amount, ret, len = len4 * 4; int amount, ret, len = len4 * 4;
@ -188,7 +186,7 @@ static bool hashfast_get_data(struct cgpu_info *hashfast, char *buf, int len4)
return true; return true;
} }
static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *info) static bool hfa_reset(struct cgpu_info *hashfast, struct hashfast_info *info)
{ {
struct hf_usb_init_header usb_init, *hu = &usb_init; struct hf_usb_init_header usb_init, *hu = &usb_init;
struct hf_usb_init_base *db; struct hf_usb_init_base *db;
@ -205,18 +203,18 @@ static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *inf
hu->operation_code = OP_USB_INIT; hu->operation_code = OP_USB_INIT;
hu->protocol = PROTOCOL_GLOBAL_WORK_QUEUE; // Protocol to use hu->protocol = PROTOCOL_GLOBAL_WORK_QUEUE; // Protocol to use
hu->hash_clock = info->hash_clock_rate; // Hash clock rate in Mhz hu->hash_clock = info->hash_clock_rate; // Hash clock rate in Mhz
hu->crc8 = hf_crc8((uint8_t *)hu); hu->crc8 = hfa_crc8((uint8_t *)hu);
applog(LOG_WARNING, "HFA%d: Sending OP_USB_INIT with GWQ protocol specified", applog(LOG_WARNING, "HFA%d: Sending OP_USB_INIT with GWQ protocol specified",
hashfast->device_id); hashfast->device_id);
if (!hashfast_send_header(hashfast, (struct hf_header *)hu, HF_USB_CMD(OP_USB_INIT))) if (!hfa_send_header(hashfast, (struct hf_header *)hu, HF_USB_CMD(OP_USB_INIT)))
return false; return false;
// Check for the correct response. // Check for the correct response.
// We extend the normal timeout - a complete device initialization, including // We extend the normal timeout - a complete device initialization, including
// bringing power supplies up from standby, etc., can take over a second. // bringing power supplies up from standby, etc., can take over a second.
for (i = 0; i < 30; i++) { for (i = 0; i < 30; i++) {
ret = hashfast_get_header(hashfast, h, &hcrc); ret = hfa_get_header(hashfast, h, &hcrc);
if (ret) if (ret)
break; break;
} }
@ -230,7 +228,7 @@ static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *inf
} }
if (h->operation_code != OP_USB_INIT) { if (h->operation_code != OP_USB_INIT) {
applog(LOG_WARNING, "HFA %d: OP_USB_INIT: Tossing packet, valid but unexpected type", hashfast->device_id); applog(LOG_WARNING, "HFA %d: OP_USB_INIT: Tossing packet, valid but unexpected type", hashfast->device_id);
hashfast_get_data(hashfast, buf, h->data_length); hfa_get_data(hashfast, buf, h->data_length);
return false; return false;
} }
@ -251,7 +249,7 @@ static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *inf
info->core_bitmap_size = (((info->asic_count * info->core_count) + 31) / 32) * 4; info->core_bitmap_size = (((info->asic_count * info->core_count) + 31) / 32) * 4;
// Get the usb_init_base structure // Get the usb_init_base structure
if (!hashfast_get_data(hashfast, (char *)&info->usb_init_base, U32SIZE(info->usb_init_base))) { if (!hfa_get_data(hashfast, (char *)&info->usb_init_base, U32SIZE(info->usb_init_base))) {
applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get usb_init_base data", applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get usb_init_base data",
hashfast->device_id); hashfast->device_id);
return false; return false;
@ -272,7 +270,7 @@ static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *inf
info->num_sequence = db->sequence_modulus; info->num_sequence = db->sequence_modulus;
// Now a copy of the config data used // Now a copy of the config data used
if (!hashfast_get_data(hashfast, (char *)&info->config_data, U32SIZE(info->config_data))) { if (!hfa_get_data(hashfast, (char *)&info->config_data, U32SIZE(info->config_data))) {
applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get config_data", applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get config_data",
hashfast->device_id); hashfast->device_id);
return false; return false;
@ -281,8 +279,8 @@ static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *inf
// Now the core bitmap // Now the core bitmap
info->core_bitmap = malloc(info->core_bitmap_size); info->core_bitmap = malloc(info->core_bitmap_size);
if (!info->core_bitmap) if (!info->core_bitmap)
quit(1, "Failed to malloc info core bitmap in hashfast_reset"); quit(1, "Failed to malloc info core bitmap in hfa_reset");
if (!hashfast_get_data(hashfast, (char *)info->core_bitmap, info->core_bitmap_size / 4)) { if (!hfa_get_data(hashfast, (char *)info->core_bitmap, info->core_bitmap_size / 4)) {
applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get core_bitmap", hashfast->device_id); applog(LOG_WARNING, "HFA %d: OP_USB_INIT failed! Failure to get core_bitmap", hashfast->device_id);
return false; return false;
} }
@ -290,17 +288,17 @@ static bool hashfast_reset(struct cgpu_info *hashfast, struct hashfast_info *inf
return true; return true;
} }
static bool hashfast_detect_common(struct cgpu_info *hashfast) static bool hfa_detect_common(struct cgpu_info *hashfast)
{ {
struct hashfast_info *info; struct hashfast_info *info;
bool ret; bool ret;
info = calloc(sizeof(struct hashfast_info), 1); info = calloc(sizeof(struct hashfast_info), 1);
if (!info) if (!info)
quit(1, "Failed to calloc hashfast_info in hashfast_detect_common"); quit(1, "Failed to calloc hashfast_info in hfa_detect_common");
hashfast->device_data = info; hashfast->device_data = info;
/* hashfast_reset should fill in details for info */ /* hashfast_reset should fill in details for info */
ret = hashfast_reset(hashfast, info); ret = hfa_reset(hashfast, info);
if (!ret) { if (!ret) {
free(info); free(info);
hashfast->device_data = NULL; hashfast->device_data = NULL;
@ -319,19 +317,19 @@ static bool hashfast_detect_common(struct cgpu_info *hashfast)
info->works = calloc(sizeof(struct work *), info->num_sequence); info->works = calloc(sizeof(struct work *), info->num_sequence);
if (!info->works) if (!info->works)
quit(1, "Failed to calloc info works in hashfast_detect_common"); quit(1, "Failed to calloc info works in hfa_detect_common");
return true; return true;
} }
static void hashfast_initialise(struct cgpu_info *hashfast) static void hfa_initialise(struct cgpu_info *hashfast)
{ {
if (hashfast->usbinfo.nodev) if (hashfast->usbinfo.nodev)
return; return;
// FIXME Do necessary initialising here // FIXME Do necessary initialising here
} }
static bool hashfast_detect_one_usb(libusb_device *dev, struct usb_find_devices *found) static bool hfa_detect_one_usb(libusb_device *dev, struct usb_find_devices *found)
{ {
struct cgpu_info *hashfast; struct cgpu_info *hashfast;
@ -346,27 +344,27 @@ static bool hashfast_detect_one_usb(libusb_device *dev, struct usb_find_devices
hashfast->usbdev->usb_type = USB_TYPE_STD; hashfast->usbdev->usb_type = USB_TYPE_STD;
hashfast_initialise(hashfast); hfa_initialise(hashfast);
add_cgpu(hashfast); add_cgpu(hashfast);
return hashfast_detect_common(hashfast); return hfa_detect_common(hashfast);
} }
static void hashfast_detect(bool hotplug) static void hfa_detect(bool hotplug)
{ {
/* Set up the CRC tables only once. */ /* Set up the CRC tables only once. */
if (!hotplug) if (!hotplug)
hf_init_crc8(); hfa_init_crc8();
usb_detect(&hashfast_drv, hashfast_detect_one_usb); usb_detect(&hashfast_drv, hfa_detect_one_usb);
} }
static bool hashfast_get_packet(struct cgpu_info *hashfast, struct hf_header *h) static bool hfa_get_packet(struct cgpu_info *hashfast, struct hf_header *h)
{ {
uint8_t hcrc; uint8_t hcrc;
bool ret; bool ret;
ret = hashfast_get_header(hashfast, h, &hcrc); ret = hfa_get_header(hashfast, h, &hcrc);
if (unlikely(!ret)) if (unlikely(!ret))
goto out; goto out;
if (unlikely(h->crc8 != hcrc)) { if (unlikely(h->crc8 != hcrc)) {
@ -374,7 +372,7 @@ static bool hashfast_get_packet(struct cgpu_info *hashfast, struct hf_header *h)
hashfast->device_id, h->crc8, hcrc); hashfast->device_id, h->crc8, hcrc);
} }
if (h->data_length > 0) if (h->data_length > 0)
ret = hashfast_get_data(hashfast, (char *)(h + 1), h->data_length); ret = hfa_get_data(hashfast, (char *)(h + 1), h->data_length);
if (unlikely(!ret)) { if (unlikely(!ret)) {
applog(LOG_WARNING, "HFA %d: Failed to get data associated with header", applog(LOG_WARNING, "HFA %d: Failed to get data associated with header",
hashfast->device_id); hashfast->device_id);
@ -417,7 +415,7 @@ static void hfa_parse_gwq_status(struct cgpu_info *hashfast, struct hashfast_inf
mutex_unlock(&info->lock); mutex_unlock(&info->lock);
} }
static void update_die_status(struct cgpu_info *hashfast, struct hashfast_info *info, static void hfa_update_die_status(struct cgpu_info *hashfast, struct hashfast_info *info,
struct hf_header *h) struct hf_header *h)
{ {
struct hf_g1_die_data *d = (struct hf_g1_die_data *)(h + 1), *ds; struct hf_g1_die_data *d = (struct hf_g1_die_data *)(h + 1), *ds;
@ -518,7 +516,7 @@ static void *hfa_read(void *arg)
while (likely(!hashfast->shutdown)) { while (likely(!hashfast->shutdown)) {
char buf[512]; char buf[512];
struct hf_header *h = (struct hf_header *)buf; struct hf_header *h = (struct hf_header *)buf;
bool ret = hashfast_get_packet(hashfast, h); bool ret = hfa_get_packet(hashfast, h);
if (unlikely(!ret)) if (unlikely(!ret))
continue; continue;
@ -528,7 +526,7 @@ static void *hfa_read(void *arg)
hfa_parse_gwq_status(hashfast, info, h); hfa_parse_gwq_status(hashfast, info, h);
break; break;
case OP_DIE_STATUS: case OP_DIE_STATUS:
update_die_status(hashfast, info, h); hfa_update_die_status(hashfast, info, h);
break; break;
case OP_NONCE: case OP_NONCE:
hfa_parse_nonce(thr, hashfast, info, h); hfa_parse_nonce(thr, hashfast, info, h);
@ -543,7 +541,7 @@ static void *hfa_read(void *arg)
return NULL; return NULL;
} }
static bool hashfast_prepare(struct thr_info *thr) static bool hfa_prepare(struct thr_info *thr)
{ {
struct cgpu_info *hashfast = thr->cgpu; struct cgpu_info *hashfast = thr->cgpu;
struct hashfast_info *info = hashfast->device_data; struct hashfast_info *info = hashfast->device_data;
@ -551,7 +549,7 @@ static bool hashfast_prepare(struct thr_info *thr)
mutex_init(&info->lock); mutex_init(&info->lock);
if (pthread_create(&info->read_thr, NULL, hfa_read, (void *)thr)) if (pthread_create(&info->read_thr, NULL, hfa_read, (void *)thr))
quit(1, "Failed to pthread_create read thr in hashfast_prepare"); quit(1, "Failed to pthread_create read thr in hfa_prepare");
cgtime(&now); cgtime(&now);
get_datestamp(hashfast->init, sizeof(hashfast->init), &now); get_datestamp(hashfast->init, sizeof(hashfast->init), &now);
@ -560,23 +558,23 @@ static bool hashfast_prepare(struct thr_info *thr)
} }
/* Figure out how many jobs to send. */ /* Figure out how many jobs to send. */
static int __hashfast_jobs(struct hashfast_info *info) static int __hfa_jobs(struct hashfast_info *info)
{ {
return info->usb_init_base.inflight_target - HF_SEQUENCE_DISTANCE(info->hash_sequence, info->device_sequence_tail); return info->usb_init_base.inflight_target - HF_SEQUENCE_DISTANCE(info->hash_sequence, info->device_sequence_tail);
} }
static int hashfast_jobs(struct hashfast_info *info) static int hfa_jobs(struct hashfast_info *info)
{ {
int ret; int ret;
mutex_lock(&info->lock); mutex_lock(&info->lock);
ret = __hashfast_jobs(info); ret = __hfa_jobs(info);
mutex_unlock(&info->lock); mutex_unlock(&info->lock);
return ret; return ret;
} }
static int64_t hashfast_scanwork(struct thr_info *thr) static int64_t hfa_scanwork(struct thr_info *thr)
{ {
struct cgpu_info *hashfast = thr->cgpu; struct cgpu_info *hashfast = thr->cgpu;
struct hashfast_info *info = hashfast->device_data; struct hashfast_info *info = hashfast->device_data;
@ -585,9 +583,9 @@ static int64_t hashfast_scanwork(struct thr_info *thr)
if (unlikely(thr->work_restart)) { if (unlikely(thr->work_restart)) {
restart: restart:
ret = hashfast_send_frame(hashfast, OP_WORK_RESTART, 0, (uint8_t *)NULL, 0); ret = hfa_send_frame(hashfast, OP_WORK_RESTART, 0, (uint8_t *)NULL, 0);
if (unlikely(!ret)) { if (unlikely(!ret)) {
ret = hashfast_reset(hashfast, info); ret = hfa_reset(hashfast, info);
if (unlikely(!ret)) { if (unlikely(!ret)) {
applog(LOG_ERR, "HFA %d: Failed to reset after write failure, disabling", applog(LOG_ERR, "HFA %d: Failed to reset after write failure, disabling",
hashfast->device_id); hashfast->device_id);
@ -596,13 +594,13 @@ restart:
} }
} }
jobs = hashfast_jobs(info); jobs = hfa_jobs(info);
if (!jobs) { if (!jobs) {
ret = restart_wait(thr, 100); ret = restart_wait(thr, 100);
if (unlikely(!ret)) if (unlikely(!ret))
goto restart; goto restart;
jobs = hashfast_jobs(info); jobs = hfa_jobs(info);
} }
while (jobs > 0) { while (jobs > 0) {
@ -630,9 +628,9 @@ restart:
op_hash_data.search_difficulty = i; op_hash_data.search_difficulty = i;
if ((sequence = info->hash_sequence + 1) >= info->num_sequence) if ((sequence = info->hash_sequence + 1) >= info->num_sequence)
sequence = 0; sequence = 0;
ret = hashfast_send_frame(hashfast, OP_HASH, sequence, (uint8_t *)&op_hash_data, sizeof(op_hash_data)); ret = hfa_send_frame(hashfast, OP_HASH, sequence, (uint8_t *)&op_hash_data, sizeof(op_hash_data));
if (unlikely(!ret)) { if (unlikely(!ret)) {
ret = hashfast_reset(hashfast, info); ret = hfa_reset(hashfast, info);
if (unlikely(!ret)) { if (unlikely(!ret)) {
applog(LOG_ERR, "HFA %d: Failed to reset after write failure, disabling", applog(LOG_ERR, "HFA %d: Failed to reset after write failure, disabling",
hashfast->device_id); hashfast->device_id);
@ -643,7 +641,7 @@ restart:
mutex_lock(&info->lock); mutex_lock(&info->lock);
info->hash_sequence = sequence; info->hash_sequence = sequence;
*(info->works + info->hash_sequence) = work; *(info->works + info->hash_sequence) = work;
jobs = __hashfast_jobs(info); jobs = __hfa_jobs(info);
mutex_unlock(&info->lock); mutex_unlock(&info->lock);
applog(LOG_DEBUG, "HFA %d: OP_HASH sequence %d search_difficulty %d work_difficulty %g", applog(LOG_DEBUG, "HFA %d: OP_HASH sequence %d search_difficulty %d work_difficulty %g",
@ -658,17 +656,17 @@ restart:
return hashes; return hashes;
} }
static struct api_data *hashfast_api_stats(struct cgpu_info __maybe_unused *cgpu) static struct api_data *hfa_api_stats(struct cgpu_info __maybe_unused *cgpu)
{ {
return NULL; return NULL;
} }
static void hashfast_init(struct cgpu_info *hashfast) static void hfa_init(struct cgpu_info *hashfast)
{ {
usb_buffer_enable(hashfast); usb_buffer_enable(hashfast);
} }
static void hashfast_shutdown(struct thr_info *thr) static void hfa_shutdown(struct thr_info *thr)
{ {
struct cgpu_info *hashfast = thr->cgpu; struct cgpu_info *hashfast = thr->cgpu;
struct hashfast_info *info = hashfast->device_data; struct hashfast_info *info = hashfast->device_data;
@ -681,11 +679,11 @@ struct device_drv hashfast_drv = {
.dname = "Hashfast", .dname = "Hashfast",
.name = "HFA", .name = "HFA",
.max_diff = 256.0, // Limit max diff to get some nonces back regardless .max_diff = 256.0, // Limit max diff to get some nonces back regardless
.drv_detect = hashfast_detect, .drv_detect = hfa_detect,
.thread_prepare = hashfast_prepare, .thread_prepare = hfa_prepare,
.hash_work = &hash_driver_work, .hash_work = &hash_driver_work,
.scanwork = hashfast_scanwork, .scanwork = hfa_scanwork,
.get_api_stats = hashfast_api_stats, .get_api_stats = hfa_api_stats,
.reinit_device = hashfast_init, .reinit_device = hfa_init,
.thread_shutdown = hashfast_shutdown, .thread_shutdown = hfa_shutdown,
}; };

Write Preview
Loading…
Cancel
Save