Provide initial set up code and structure initialisation for hashfast device detection.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
diff --git a/cgminer.c b/cgminer.c
index ab6f72c..2d28bdc 100644
--- a/cgminer.c
+++ b/cgminer.c
@@ -62,10 +62,6 @@
#include "driver-bflsc.h"
#endif
-#ifdef USE_HASHFAST
-#include "driver-hashfast.h"
-#endif
-
#if defined(unix) || defined(__APPLE__)
#include <errno.h>
#include <fcntl.h>
diff --git a/driver-hashfast.c b/driver-hashfast.c
index 027a131..b6e1816 100644
--- a/driver-hashfast.c
+++ b/driver-hashfast.c
@@ -20,8 +20,144 @@
static hf_info_t **hashfast_infos;
struct device_drv hashfast_drv;
+static int hashfast_reset(struct cgpu_info __maybe_unused *hashfast)
+{
+ return 0;
+}
+
+static bool hashfast_detect_common(struct cgpu_info *hashfast, int baud)
+{
+ hf_core_t **c, *core;
+ hf_info_t *info;
+ hf_job_t *j;
+ int i, k, ret;
+
+ hashfast_infos = realloc(hashfast_infos, sizeof(hf_info_t *) * (total_devices + 1));
+ if (unlikely(!hashfast_infos))
+ quit(1, "Failed to realloc hashfast_infos in hashfast_detect_common");
+ // Assume success, allocate info ahead of reset, so reset can fill fields in
+ info = calloc(sizeof(hf_info_t), 1);
+ if (unlikely(!info))
+ quit(1, "Failed to calloc info in hashfast_detect_common");
+ hashfast_infos[hashfast->device_id] = info;
+ info->tacho_enable = 1;
+ info->miner_count = 1;
+ info->max_search_difficulty = 12;
+ info->baud_rate = baud;
+
+ ret = hashfast_reset(hashfast);
+ if (unlikely(ret)) {
+ free(info);
+ hashfast_infos[hashfast->device_id] = NULL;
+ return false;
+ }
+
+ /* 1 Pending, 1 active for each */
+ info->inflight_target = info->asic_count * info->core_count *2;
+
+ switch (info->device_type) {
+ default:
+ case HFD_G1:
+ /* Implies hash_loops = 0 for full nonce range */
+ break;
+ case HFD_ExpressAGX:
+ /* ExpressAGX */
+ info->hash_loops = 1 << 26;
+ break;
+ case HFD_VC709:
+ /* Virtex 7
+ * Adjust according to fast or slow configuration */
+ if (info->core_count > 5)
+ info->hash_loops = 1 << 26;
+ else
+ info->hash_loops = 1 << 30;
+ break;
+ }
+ applog(LOG_INFO, "Hashfast Detect: chips %d cores %d inflight_target %d entries",
+ info->asic_count, info->core_count, info->inflight_target);
+
+ /* Initialize list heads */
+ info->active.next = &info->active;
+ info->active.prev = &info->active;
+ info->inactive.next = &info->inactive;
+ info->inactive.prev = &info->inactive;
+
+ /* Allocate core data structures */
+ info->cores = calloc(info->asic_count, sizeof(hf_core_t *));
+ if (unlikely(!info->cores))
+ quit(1, "Failed to calloc info cores in hashfast_detect_common");
+ c = info->cores;
+
+ for (i = 0; i < info->asic_count; i++) {
+ *c = calloc(info->core_count, sizeof(hf_core_t));
+ if (unlikely(!*c))
+ quit(1, "Failed to calloc hf_core_t in hashfast_detect_common");
+ for (k = 0, core = *c; k < info->core_count; k++, core++)
+ core->enabled = 1;
+ c++;
+ }
+
+ /* Now allocate enough structures to hold all the in-flight work
+ * 2 per core - one active and one pending. These go on the inactive
+ * queue, and get used/recycled as required. */
+ for (i = 0; i < info->asic_count * info->core_count * 2; i++) {
+ j = calloc(sizeof(hf_job_t), 1);
+ if (unlikely(!j))
+ quit(1, "Failed to calloc hf_job_t in hashfast_detect_common");
+ list_add(&info->inactive, &j->l);
+ }
+
+ info->inactive_count = info->asic_count * info->core_count * 2;
+ applog(LOG_INFO, "Hashfast Detect: Allocated %d job entries",
+ info->inflight_target);
+
+ // Finally, allocate enough space to hold the work array.
+ info->max_work = info->inflight_target;
+ info->num_sequence = 1024;
+
+ info->work = calloc(info->max_work, sizeof(hf_work_t));
+ if (unlikely(!info->work))
+ quit(1, "Failed to calloc info work in hashfast_detect_common");
+ applog(LOG_INFO, "Hashfast Detect: Allocated space for %d work entries", info->inflight_target);
+
+ return true;
+}
+
+static void hashfast_usb_initialise(struct cgpu_info *hashfast)
+{
+ if (hashfast->usbinfo.nodev)
+ return;
+ // FIXME Do necessary initialising here
+}
+
+static bool hashfast_detect_one_usb(libusb_device *dev, struct usb_find_devices *found)
+{
+ struct cgpu_info *hashfast;
+ int baud = DEFAULT_BAUD_RATE;
+
+ hashfast = usb_alloc_cgpu(&hashfast_drv, HASHFAST_MINER_THREADS);
+ if (!hashfast)
+ return false;
+
+ if (!usb_init(hashfast, dev, found)) {
+ free(hashfast->device_data);
+ hashfast->device_data = NULL;
+ hashfast = usb_free_cgpu(hashfast);
+ return false;
+ }
+
+ hashfast->usbdev->usb_type = USB_TYPE_STD;
+ hashfast->usbdev->PrefPacketSize = HASHFAST_USB_PACKETSIZE;
+
+ hashfast_usb_initialise(hashfast);
+
+ add_cgpu(hashfast);
+ return hashfast_detect_common(hashfast, baud);
+}
+
static void hashfast_detect(void)
{
+ usb_detect(&hashfast_drv, hashfast_detect_one_usb);
}
static bool hashfast_prepare(struct thr_info __maybe_unused *thr)
diff --git a/driver-hashfast.h b/driver-hashfast.h
index dc0c133..155eb87 100644
--- a/driver-hashfast.h
+++ b/driver-hashfast.h
@@ -15,6 +15,8 @@
#include "miner.h"
#include "elist.h"
+#define HASHFAST_MINER_THREADS 1
+
// Some serial protocol definitions
#define DEFAULT_BAUD_RATE 115200