|
|
@@ -0,0 +1,252 @@
|
|
|
+/*
|
|
|
+ * Copyright 2014 Nate Woolls
|
|
|
+ * Copyright 2014 ZeusMiner Team
|
|
|
+ *
|
|
|
+ * 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 <stdbool.h>
|
|
|
+#include <stdint.h>
|
|
|
+#include <string.h>
|
|
|
+#include <math.h>
|
|
|
+
|
|
|
+#include "miner.h"
|
|
|
+#include "driver-icarus.h"
|
|
|
+#include "lowl-vcom.h"
|
|
|
+
|
|
|
+#define ZEUSMINER_IO_SPEED 115200
|
|
|
+
|
|
|
+#define ZEUSMINER_CHIP_GEN1_CORES 8
|
|
|
+#define ZEUSMINER_CHIP_CORES ZEUSMINER_CHIP_GEN1_CORES
|
|
|
+#define ZEUSMINER_CHIPS_COUNT_MAX 1
|
|
|
+#define ZEUSMINER_CHIPS_COUNT 6
|
|
|
+#define ZEUSMINER_DEFAULT_CLOCK 328
|
|
|
+#define ZEUSMINER_MIN_CLOCK 200
|
|
|
+#define ZEUSMINER_MAX_CLOCK 383
|
|
|
+
|
|
|
+
|
|
|
+BFG_REGISTER_DRIVER(zeusminer_drv)
|
|
|
+
|
|
|
+static
|
|
|
+const struct bfg_set_device_definition zeusminer_set_device_funcs[];
|
|
|
+
|
|
|
+// device helper functions
|
|
|
+
|
|
|
+static
|
|
|
+uint32_t zeusminer_calc_clk_header(uint16_t freq)
|
|
|
+{
|
|
|
+ //set clk_reg based on chip_clk
|
|
|
+ uint32_t clk_reg = (uint32_t)(freq * 2 / 3);
|
|
|
+
|
|
|
+ //clock speed mask for header
|
|
|
+ uint32_t clk_header = (clk_reg << 24)+ ((0xff - clk_reg) << 16);
|
|
|
+
|
|
|
+ return clk_header;
|
|
|
+}
|
|
|
+
|
|
|
+// ICARUS_INFO functions - driver-icarus.h
|
|
|
+
|
|
|
+// device detection
|
|
|
+
|
|
|
+static
|
|
|
+bool zeusminer_detect_one(const char *devpath)
|
|
|
+{
|
|
|
+ struct device_drv *drv = &zeusminer_drv;
|
|
|
+
|
|
|
+ struct ICARUS_INFO *info = calloc(1, sizeof(struct ICARUS_INFO));
|
|
|
+ if (unlikely(!info))
|
|
|
+ quit(1, "Failed to malloc ICARUS_INFO");
|
|
|
+
|
|
|
+ char scrypt_golden_ob[] =
|
|
|
+ "55aa" //Freq is set to 0x55*1.5=85Mhz
|
|
|
+ "0001" //We want to find a Nonce which result’s diff is at least 32768
|
|
|
+ "00038000" //Starting Nonce
|
|
|
+ "063b0b1b" //Bits (target in compact form)
|
|
|
+ "028f3253" //Timestamp
|
|
|
+ "5e900609c15dc49a42b1d8492a6dd4f8f15295c989a1decf584a6aa93be26066" //Merkle root
|
|
|
+ "d3185f55ef635b5865a7a79b7fa74121a6bb819da416328a9bd2f8cef72794bf" //Previous hash
|
|
|
+ "02000000"; //Version
|
|
|
+
|
|
|
+ const char scrypt_golden_nonce[] = "00038d26";
|
|
|
+
|
|
|
+ *info = (struct ICARUS_INFO){
|
|
|
+ .baud = ZEUSMINER_IO_SPEED,
|
|
|
+ .timing_mode = MODE_DEFAULT,
|
|
|
+ .do_icarus_timing = true,
|
|
|
+ .work_division = 1,
|
|
|
+ .fpga_count = 1,
|
|
|
+ .probe_read_count = 5,
|
|
|
+ .golden_nonce = (char*)scrypt_golden_nonce,
|
|
|
+ .chips = ZEUSMINER_CHIPS_COUNT,
|
|
|
+ .freq = ZEUSMINER_DEFAULT_CLOCK,
|
|
|
+ };
|
|
|
+
|
|
|
+ //pick up any user-defined settings passed in via --set
|
|
|
+ drv_set_defaults(drv, zeusminer_set_device_funcs, info, devpath, detectone_meta_info.serial, 1);
|
|
|
+
|
|
|
+ //3 bits of 32 bits nonce are reserved for cores’ combination
|
|
|
+ //10 bits of 32 bits nonce are reserved for chips’ combination
|
|
|
+ //the nonce range is split into 2^(10+3) parts
|
|
|
+ info->work_division = 8192;
|
|
|
+
|
|
|
+ info->fpga_count = info->chips * ZEUSMINER_CHIP_CORES;
|
|
|
+
|
|
|
+ //send the requested Chip Speed with the detect golden OB
|
|
|
+ //we use the time this request takes in order to calc hashes
|
|
|
+ //so we need to use the same Chip Speed used when hashing
|
|
|
+ uint32_t clk_header = zeusminer_calc_clk_header(info->freq);
|
|
|
+ char clk_header_str[10];
|
|
|
+ sprintf(clk_header_str, "%08x", clk_header + 1);
|
|
|
+ memcpy(scrypt_golden_ob, clk_header_str, 8);
|
|
|
+
|
|
|
+ info->golden_ob = scrypt_golden_ob;
|
|
|
+
|
|
|
+ if (!icarus_detect_custom(devpath, drv, info))
|
|
|
+ {
|
|
|
+ free(info);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ double duration_sec;
|
|
|
+ const double hash_count = (double)0xd26;
|
|
|
+ uint64_t default_hashes_per_core = (((info->freq * 2) / 3) * 1024) / ZEUSMINER_CHIP_CORES;
|
|
|
+
|
|
|
+ if (info->ignore_golden_nonce)
|
|
|
+ duration_sec = hash_count / default_hashes_per_core;
|
|
|
+ else
|
|
|
+ duration_sec = ((double)(info->golden_tv.tv_sec) + ((double)(info->golden_tv.tv_usec)) / ((double)1000000));
|
|
|
+
|
|
|
+ //determines how the hash rate is calculated when no nonce is returned
|
|
|
+ info->Hs = (double)(duration_sec / hash_count / info->chips / ZEUSMINER_CHIP_CORES);
|
|
|
+
|
|
|
+ //set the read_count (how long to wait for a result) based on chips, cores, and time to find a nonce
|
|
|
+ int chips_count_max = ZEUSMINER_CHIPS_COUNT_MAX;
|
|
|
+ if (info->chips > chips_count_max)
|
|
|
+ chips_count_max = upper_power_of_two(info->chips);
|
|
|
+ //golden_speed_per_core is the number of hashes / second / core
|
|
|
+ uint64_t golden_speed_per_core = (uint64_t)(hash_count / duration_sec);
|
|
|
+ //don't combine the following two lines - overflows leaving info->read_count at 0
|
|
|
+ info->read_count = (uint32_t)((4294967296 * 10) / (ZEUSMINER_CHIP_CORES * chips_count_max * golden_speed_per_core * 2));
|
|
|
+ info->read_count = info->read_count * 3/4;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+// support for --set-device
|
|
|
+// must be set before probing the device
|
|
|
+
|
|
|
+static
|
|
|
+const char *zeusminer_set_clock(struct cgpu_info * const device, const char * const option, const char * const setting, char * const replybuf, enum bfg_set_device_replytype * const success)
|
|
|
+{
|
|
|
+ struct ICARUS_INFO * const info = device->device_data;
|
|
|
+
|
|
|
+ int val = atoi(setting);
|
|
|
+
|
|
|
+ if (val < ZEUSMINER_MIN_CLOCK || val > ZEUSMINER_MAX_CLOCK) {
|
|
|
+ sprintf(replybuf, "invalid clock: '%s' valid range %d-%d",
|
|
|
+ setting, ZEUSMINER_MIN_CLOCK, ZEUSMINER_MAX_CLOCK);
|
|
|
+ return replybuf;
|
|
|
+ }
|
|
|
+
|
|
|
+ info->freq = val;
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static
|
|
|
+const char *zeusminer_set_chips(struct cgpu_info * const device, const char * const option, const char * const setting, char * const replybuf, enum bfg_set_device_replytype * const success)
|
|
|
+{
|
|
|
+ struct ICARUS_INFO * const info = device->device_data;
|
|
|
+
|
|
|
+ info->chips = atoi(setting);
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static
|
|
|
+const char *zeusminer_set_ignore_golden_nonce(struct cgpu_info * const device, const char * const option, const char * const setting, char * const replybuf, enum bfg_set_device_replytype * const success)
|
|
|
+{
|
|
|
+ struct ICARUS_INFO * const info = device->device_data;
|
|
|
+
|
|
|
+ info->ignore_golden_nonce = atoi(setting) == 1;
|
|
|
+
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static
|
|
|
+const struct bfg_set_device_definition zeusminer_set_device_funcs[] = {
|
|
|
+ { "clock", zeusminer_set_clock, NULL },
|
|
|
+ { "chips", zeusminer_set_chips, NULL },
|
|
|
+ { "ignore_golden_nonce",zeusminer_set_ignore_golden_nonce, NULL },
|
|
|
+ { NULL },
|
|
|
+};
|
|
|
+
|
|
|
+static
|
|
|
+bool zeusminer_lowl_probe(const struct lowlevel_device_info * const info)
|
|
|
+{
|
|
|
+ return vcom_lowl_probe_wrapper(info, zeusminer_detect_one);
|
|
|
+}
|
|
|
+
|
|
|
+// device_drv functions - miner.h
|
|
|
+
|
|
|
+static
|
|
|
+bool zeusminer_thread_init(struct thr_info * const thr)
|
|
|
+{
|
|
|
+ struct cgpu_info * const device = thr->cgpu;
|
|
|
+
|
|
|
+ device->min_nonce_diff = 1./0x10000;
|
|
|
+
|
|
|
+ return icarus_init(thr);
|
|
|
+}
|
|
|
+
|
|
|
+static
|
|
|
+bool zeusminer_job_prepare(struct thr_info *thr, struct work *work, __maybe_unused uint64_t max_nonce)
|
|
|
+{
|
|
|
+ struct cgpu_info * const device = thr->cgpu;
|
|
|
+ struct icarus_state * const state = thr->cgpu_data;
|
|
|
+ struct ICARUS_INFO * const info = device->device_data;
|
|
|
+
|
|
|
+ uint32_t clk_header = zeusminer_calc_clk_header(info->freq);
|
|
|
+ uint32_t diff = work->nonce_diff * 0x10000;
|
|
|
+ uint32_t target_me = 0xffff / diff;
|
|
|
+ uint32_t header = clk_header + target_me;
|
|
|
+
|
|
|
+ swabn(state->ob_bin, (uint8_t *)&header, 4);
|
|
|
+ swabn(state->ob_bin + 4, work->data, 80);
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+// device_drv definition - miner.h
|
|
|
+
|
|
|
+static
|
|
|
+void zeusminer_drv_init()
|
|
|
+{
|
|
|
+ // based on Icarus
|
|
|
+ zeusminer_drv = icarus_drv;
|
|
|
+
|
|
|
+ // metadata
|
|
|
+ zeusminer_drv.dname = "zeusminer";
|
|
|
+ zeusminer_drv.name = "ZUS";
|
|
|
+ zeusminer_drv.supported_algos = POW_SCRYPT;
|
|
|
+
|
|
|
+ // detect device
|
|
|
+ zeusminer_drv.lowl_probe = zeusminer_lowl_probe;
|
|
|
+
|
|
|
+ // initialize thread
|
|
|
+ zeusminer_drv.thread_init = zeusminer_thread_init;
|
|
|
+
|
|
|
+ // Icarus scanhash mining hooks
|
|
|
+ zeusminer_drv.job_prepare = zeusminer_job_prepare;
|
|
|
+
|
|
|
+ // specify driver probe priority
|
|
|
+ ++zeusminer_drv.probe_priority;
|
|
|
+}
|
|
|
+
|
|
|
+struct device_drv zeusminer_drv =
|
|
|
+{
|
|
|
+ .drv_init = zeusminer_drv_init,
|
|
|
+};
|
Nate Woolls