Merge commit 'de860a5' into littlefury

Conflicts:
	Makefile.am
	libbitfury.c
	libbitfury.h

Makefile.am

@@ -212,6 +212,10 @@ endif
 
 if HAS_BITFURY
 bfgminer_SOURCES += driver-bitfury.c libbitfury.c libbitfury.h spidevc.h spidevc.c tm_i2c.h tm_i2c.c
+
+if HAS_LITTLEFURY
+bfgminer_SOURCES += driver-littlefury.c
+endif
 endif
 
 bin_PROGRAMS += bfgminer-rpc

configure.ac

@@ -430,10 +430,9 @@ fi
 AM_CONDITIONAL([HAS_ZTEX], [test x$ztex = xyes])
 
 
-bitfury="no"
-
+bitfury=auto
 AC_ARG_ENABLE([bitfury],
-	[AC_HELP_STRING([--enable-bitfury],[Compile support for Bitfury (default disabled)])],
+	[AC_HELP_STRING([--disable-bitfury],[Compile support for Bitfury (default enabled)])],
 	[bitfury=$enableval]
 	)
 if test "x$bitfury" = xyes; then
@@ -442,6 +441,26 @@ fi
 AM_CONDITIONAL([HAS_BITFURY], [test x$bitfury = xyes])
 
 
+littlefury=auto
+AC_ARG_ENABLE([littlefury],
+	[AC_HELP_STRING([--disable-littlefury],[Compile support for LittleFury (default enabled)])],
+	[littlefury=$enableval]
+	)
+if test "x$littlefury" = "xno"; then
+	true
+elif test "x$bitfury" = "xyes"; then
+	littlefury=yes
+elif test "x$littlefury" = "xyes"; then
+	AC_MSG_ERROR([You explicitly disabled Bitfury and explicitly enabled LittleFury])
+else
+	littlefury=no
+fi
+if test "x$littlefury" = "xyes"; then
+	AC_DEFINE([USE_LITTLEFURY], [1], [Defined to 1 if LittleFury support is wanted])
+fi
+AM_CONDITIONAL([HAS_LITTLEFURY], [test x$littlefury = xyes])
+
+
 if test "x$x6500$ztex" = "xnono"; then
 	libusb=no
 	LIBUSB_LIBS=''

driver-littlefury.c

@@ -0,0 +1,385 @@
+/*
+ * Copyright 2013 Luke Dashjr
+ *
+ * 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 "config.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "deviceapi.h"
+#include "fpgautils.h"
+#include "libbitfury.h"
+#include "logging.h"
+#include "miner.h"
+#include "spidevc.h"
+#include "util.h"
+
+
+enum littlefury_opcode {
+	LFOP_VERSION = 0,
+	LFOP_SPI     = 1,
+	LFOP_REGVOLT = 2,
+	LFOP_REGINFO = 3,
+	LFOP_REGPWR  = 4,
+	LFOP_TEMP    = 5,
+	LFOP_LED     = 6,
+	LFOP_ADC     = 7,
+};
+
+struct device_drv littlefury_drv;
+
+static uint16_t crc16tab[] = {
+	0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
+	0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
+	0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
+	0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
+	0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
+	0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
+	0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
+	0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
+	0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
+	0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
+	0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
+	0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
+	0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
+	0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
+	0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
+	0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
+	0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
+	0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
+	0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
+	0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
+	0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
+	0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
+	0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
+	0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
+	0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
+	0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
+	0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
+	0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
+	0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
+	0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
+	0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
+	0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0,
+};
+
+static
+uint16_t crc16_floating(uint16_t next_byte, uint16_t seed)
+{
+	return ((seed << 8) ^ crc16tab[(seed >> 8) ^ next_byte]) & 0xFFFF;
+}
+
+static
+uint16_t crc16(void *p, size_t sz)
+{
+	const uint8_t * const s = p;
+	uint16_t crc = 0xFFFF;
+	for (size_t i = 0; i < sz; ++i)
+		crc = crc16_floating(s[i], crc);
+	return crc;
+}
+
+static
+bool bitfury_do_packet(int prio, const char *repr, const int fd, void * const buf, uint8_t * const bufsz, const uint8_t op, const void * const payload, const uint8_t payloadsz)
+{
+	uint16_t crc;
+	size_t sz;
+	uint8_t pkt[0x106];
+	bool b;
+	
+	{
+		sz = 2 + 1 + 1 + payloadsz + 2;
+		pkt[0] = 0xab;
+		pkt[1] = 0xcd;
+		pkt[2] = op;
+		pkt[3] = payloadsz;
+		if (payloadsz)
+			memcpy(&pkt[4], payload, payloadsz);
+		crc = crc16(&pkt[2], 2 + (size_t)payloadsz);
+		pkt[sz - 2] = crc >> 8;
+		pkt[sz - 1] = crc & 0xff;
+		if (unlikely(opt_dev_protocol))
+		{
+			char hex[(sz * 2) + 1];
+			bin2hex(hex, pkt, sz);
+			applog(LOG_DEBUG, "%s: DEVPROTO: SEND %s", repr, hex);
+		}
+		if (sz != write(fd, pkt, sz))
+		{
+			applog(prio, "%s: Failed to write packet", repr);
+			return false;
+		}
+	}
+	
+	{
+		if (4 != read(fd, pkt, 4) || pkt[0] != 0xab || pkt[1] != 0xcd || pkt[2] != op)
+		{
+			applog(prio, "%s: Failed to read correct packet header", repr);
+			return false;
+		}
+		sz = pkt[3] + 2;
+		if (sz != read(fd, &pkt[4], sz))
+		{
+			applog(prio, "%s: Failed to read packet payload (len=%d)", repr, (int)sz);
+			return false;
+		}
+		crc = (pkt[sz + 2] << 8) | pkt[sz + 3];
+		b = (crc != crc16(&pkt[2], sz));
+		if (unlikely(opt_dev_protocol || b))
+		{
+			char hex[((sz + 4) * 2) + 1];
+			bin2hex(hex, pkt, sz + 4);
+			applog(b ? prio : LOG_DEBUG, "%s: DEVPROTO: RECV %s", repr, hex);
+			if (b)
+			{
+				applog(prio, "%s: Packet checksum mismatch", repr);
+				return false;
+			}
+		}
+		memcpy(buf, &pkt[4], (*bufsz < pkt[3] ? pkt[3] : *bufsz));
+		*bufsz = pkt[3];
+	}
+	
+	return true;
+}
+
+static
+bool littlefury_txrx(struct spi_port *port)
+{
+	const struct cgpu_info * const cgpu = port->cgpu;
+	const void *wrbuf = spi_gettxbuf(port);
+	void *rdbuf = spi_getrxbuf(port);
+	size_t bufsz = spi_getbufsz(port);
+	uint8_t rbufsz, xfer;
+	const int logprio = port->logprio;
+	const char * const repr = port->repr;
+	const int fd = cgpu->device->device_fd;
+	
+	rbufsz = 1;
+	if (!bitfury_do_packet(logprio, repr, fd, rdbuf, &rbufsz, LFOP_SPI, NULL, 0))
+		return false;
+	
+	while (bufsz)
+	{
+		xfer = (bufsz > 32) ? 32 : bufsz;
+		rbufsz = xfer;
+		if (!bitfury_do_packet(logprio, repr, fd, rdbuf, &rbufsz, LFOP_SPI, wrbuf, xfer))
+			return false;
+		if (rbufsz < xfer)
+		{
+			applog(port->logprio, "%s: SPI: Got fewer bytes back than sent (%d < %d)",
+			       repr, rbufsz, xfer);
+			return false;
+		}
+		bufsz -= xfer;
+		rdbuf += xfer;
+		wrbuf += xfer;
+	}
+	
+	return true;
+}
+
+static
+bool littlefury_detect_one(const char *devpath)
+{
+	int fd, chips;
+	uint8_t buf[255], bufsz;
+	struct spi_port spi;
+	struct cgpu_info dummy;
+	char *devname;
+	
+	fd = serial_open(devpath, 0, 10, true);
+	applog(LOG_DEBUG, "%s: %s %s",
+	       littlefury_drv.dname,
+	       ((fd == -1) ? "Failed to open" : "Successfully opened"),
+	       devpath);
+	
+	if (unlikely(fd == -1))
+		goto err;
+	
+	bufsz = sizeof(buf);
+	if (!bitfury_do_packet(LOG_DEBUG, littlefury_drv.dname, fd, buf, &bufsz, LFOP_VERSION, NULL, 0))
+		goto err;
+	
+	if (bufsz < 4)
+	{
+		applog(LOG_DEBUG, "%s: Incomplete version response", littlefury_drv.dname);
+		goto err;
+	}
+	
+	devname = strndup((char*)&buf[4], bufsz - 4);
+	applog(LOG_DEBUG, "%s: Identified %s %d.%d.%d (features %02x)",
+	       littlefury_drv.dname, devname, buf[0], buf[1], buf[2], buf[3]);
+	
+	bufsz = sizeof(buf);
+	if (!(bitfury_do_packet(LOG_DEBUG, littlefury_drv.dname, fd, buf, &bufsz, LFOP_REGPWR, "\1", 1) && bufsz && buf[0]))
+		applog(LOG_WARNING, "%s: Unable to power on chip(s) for %s",
+		       littlefury_drv.dname, devpath);
+	
+	dummy.device = &dummy;
+	dummy.device_fd = fd;
+	spi = (struct spi_port){
+		.txrx = littlefury_txrx,
+		.cgpu = &dummy,
+		.repr = littlefury_drv.dname,
+		.logprio = LOG_DEBUG,
+	};
+	
+	chips = libbitfury_detectChips1(&spi);
+	if (!chips) {
+		applog(LOG_WARNING, "%s: No Bitfury chips detected on %s",
+		       littlefury_drv.dname, devpath);
+		free(devname);
+		goto err;
+	} else {
+		applog(LOG_DEBUG, "%s: %d chips detected",
+		       littlefury_drv.dname, chips);
+	}
+	
+	bufsz = sizeof(buf);
+	bitfury_do_packet(LOG_DEBUG, littlefury_drv.dname, fd, buf, &bufsz, LFOP_REGPWR, "\0", 1);
+	
+	serial_close(fd);
+	
+	struct cgpu_info *cgpu;
+	cgpu = malloc(sizeof(*cgpu));
+	*cgpu = (struct cgpu_info){
+		.drv = &littlefury_drv,
+		.device_path = strdup(devpath),
+		.device_fd = -1,
+		.deven = DEV_ENABLED,
+		.procs = chips,
+		.threads = 1,
+		.name = devname,
+		.cutofftemp = 85,
+	};
+	
+	return add_cgpu(cgpu);
+
+err:
+	return false;
+}
+
+static
+int littlefury_detect_auto(void)
+{
+	return serial_autodetect(littlefury_detect_one, "LittleFury");
+}
+
+static
+void littlefury_detect(void)
+{
+	serial_detect_auto(&littlefury_drv, littlefury_detect_one, littlefury_detect_auto);
+}
+
+static
+bool littlefury_thread_init(struct thr_info *thr)
+{
+	struct cgpu_info * const cgpu = thr->cgpu;
+	struct cgpu_info *proc;
+	struct spi_port *spi;
+	struct bitfury_device *bitfury;
+	uint8_t buf[1], bufsz = 1;
+	int fd;
+	int i = 0;
+	
+	for (proc = cgpu; proc; proc = proc->next_proc)
+	{
+		spi = malloc(sizeof(*spi));
+		*spi = (struct spi_port){
+			.txrx = littlefury_txrx,
+			.cgpu = proc,
+			.repr = proc->proc_repr,
+			.logprio = LOG_ERR,
+		};
+		
+		bitfury = malloc(sizeof(*bitfury));
+		*bitfury = (struct bitfury_device){
+			.spi = spi,
+			.fasync = i++,
+		};
+		
+		proc->device_data = bitfury;
+	}
+	
+	fd = cgpu->device_fd = serial_open(cgpu->device_path, 0, 10, true);
+	if (unlikely(fd == -1))
+	{
+		applog(LOG_DEBUG, "%s: %s %s",
+		       cgpu->dev_repr, "Failed to open", cgpu->device_path);
+		return true;
+	}
+	
+	if (!(bitfury_do_packet(LOG_DEBUG, littlefury_drv.dname, fd, buf, &bufsz, LFOP_REGPWR, "\1", 1) && bufsz && buf[0]))
+		applog(LOG_WARNING, "%s: Unable to power on chip(s)", cgpu->dev_repr);
+	
+	return true;
+}
+
+static
+bool littlefury_do_io(struct thr_info *thr)
+{
+	struct cgpu_info * const proc = thr->cgpu;
+	struct bitfury_device * const bitfury = proc->device_data;
+	bitfury->results_n = 0;
+	libbitfury_sendHashData1(proc->proc_id, bitfury, thr->work);
+	if (bitfury->job_switched)
+	{
+		mt_job_transition(thr);
+		job_start_complete(thr);
+	}
+	if (thr->work && bitfury->results_n)
+		for (int i = bitfury->results_n; i--; )
+			submit_nonce(thr, thr->work, be32toh(bitfury->results[i]));
+	timer_set_delay_from_now(&thr->tv_poll, 10000);
+	return true;
+}
+
+static
+void littlefury_poll(struct thr_info *thr)
+{
+	littlefury_do_io(thr);
+}
+
+static
+bool littlefury_job_prepare(struct thr_info *thr, struct work *work, __maybe_unused uint64_t max_nonce)
+{
+	struct bitfury_device * const bitfury = thr->cgpu->device_data;
+	work_to_payload(&bitfury->payload, thr->next_work);
+	return true;
+}
+
+static
+void littlefury_job_start(struct thr_info *thr)
+{
+	littlefury_do_io(thr);
+}
+
+static
+int64_t littlefury_job_process_results(struct thr_info *thr, struct work *work, bool stopping)
+{
+	if (unlikely(stopping))
+		timer_unset(&thr->tv_poll);
+	return 0x100000000;
+}
+
+struct device_drv littlefury_drv = {
+	.dname = "littlefury",
+	.name = "LFY",
+	.drv_detect = littlefury_detect,
+	.minerloop = minerloop_async,
+	
+	.thread_init = littlefury_thread_init,
+	.job_prepare = littlefury_job_prepare,
+	.job_start = littlefury_job_start,
+	.poll = littlefury_poll,
+	.job_process_results = littlefury_job_process_results,
+};

libbitfury.c

@@ -451,232 +451,237 @@ void work_to_payload(struct bitfury_payload *p, struct work *w) {
 	p->nbits = bswap_32(*(unsigned *)(flipped_data + 72));
 }
 
-void libbitfury_sendHashData(struct bitfury_device *bf, int chip_n) {
-	struct spi_port *port = bf->spi;
-	int chip_id;
-	static unsigned second_run;
-
-	for (chip_id = 0; chip_id < chip_n; chip_id++) {
-		struct bitfury_device *d = bf + chip_id;
-		unsigned *newbuf = d->newbuf;
-		unsigned *oldbuf = d->oldbuf;
-		struct bitfury_payload *p = &(d->payload);
-		struct bitfury_payload *op = &(d->opayload);
-		struct bitfury_payload *o2p = &(d->o2payload);
-		struct timespec d_time;
-		struct timespec time;
-		int smart = 0;
-		int chip = d->fasync;
-		int slot = d->slot;
-
-		memcpy(atrvec, p, 20*4);
-		ms3_compute(atrvec);
+void libbitfury_sendHashData1(int chip_id, struct bitfury_device *d, bool second_run)
+{
+	struct spi_port *port = d->spi;
+	unsigned *newbuf = d->newbuf;
+	unsigned *oldbuf = d->oldbuf;
+	struct bitfury_payload *p = &(d->payload);
+	struct bitfury_payload *op = &(d->opayload);
+	struct bitfury_payload *o2p = &(d->o2payload);
+	struct timespec d_time;
+	struct timespec time;
+	int smart = 0;
+	int chip = d->fasync;
+	int slot = d->slot;
+
+	memcpy(atrvec, p, 20*4);
+	ms3_compute(atrvec);
+
+	clock_gettime(CLOCK_REALTIME, &(time));
+
+	if (!second_run) {
+		d->predict2 = d->predict1 = time;
+		d->counter1 = d->counter2 = 0;
+		d->req2_done = 0;
+	};
 
+	d_time = t_diff(time, d->predict1);
+	if (d_time.tv_sec < 0 && (d->req2_done || !smart)) {
+		d->otimer1 = d->timer1;
+		d->timer1 = time;
+		/* Programming next value */
+		spi_clear_buf(port);
+		spi_emit_break(port);
+		spi_emit_fasync(port, chip);
+		spi_emit_data(port, 0x3000, &atrvec[0], 19*4);
+		if (smart) {
+			config_reg(port, 3, 0);
+		}
+		tm_i2c_set_oe(slot);
 		clock_gettime(CLOCK_REALTIME, &(time));
-
-		if (!second_run) {
-			d->predict2 = d->predict1 = time;
-			d->counter1 = d->counter2 = 0;
-			d->req2_done = 0;
-		};
-
 		d_time = t_diff(time, d->predict1);
-		if (d_time.tv_sec < 0 && (d->req2_done || !smart)) {
-			d->otimer1 = d->timer1;
-			d->timer1 = time;
-			/* Programming next value */
-			spi_clear_buf(port);
-			spi_emit_break(port);
-			spi_emit_fasync(port, chip);
-			spi_emit_data(port, 0x3000, &atrvec[0], 19*4);
-			if (smart) {
-				config_reg(port, 3, 0);
-			}
-			tm_i2c_set_oe(slot);
-			clock_gettime(CLOCK_REALTIME, &(time));
-			d_time = t_diff(time, d->predict1);
-			spi_txrx(port);
-			tm_i2c_clear_oe(slot);
-			memcpy(newbuf, spi_getrxbuf(port)+4 + chip, 17*4);
-
-			d->job_switched = newbuf[16] != oldbuf[16];
-
-			int i;
-			int results_num = 0;
-			int found = 0;
-			unsigned * results = d->results;
-
-			d->old_nonce = 0;
-			d->future_nonce = 0;
-			for (i = 0; i < 16; i++) {
-				if (oldbuf[i] != newbuf[i] && op && o2p) {
-					unsigned pn; //possible nonce
-					unsigned int s = 0; //TODO zero may be solution
-					if ((newbuf[i] & 0xFF) == 0xE0)
-						continue;
-					pn = decnonce(newbuf[i]);
-					s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn) ? pn : 0;
-					s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn-0x00400000) ? pn - 0x00400000 : 0;
-					s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn-0x00800000) ? pn - 0x00800000 : 0;
-					s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn+0x02800000) ? pn + 0x02800000 : 0;
-					s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn+0x02C00000) ? pn + 0x02C00000 : 0;
-					s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn+0x00400000) ? pn + 0x00400000 : 0;
-					if (s) {
-						int k;
-						int dup = 0;
-						for (k = 0; k < results_num; k++) {
-							if (results[k] == bswap_32(s)) {
-								dup = 1;
-							}
-						}
-						if (!dup) {
-							results[results_num++] = bswap_32(s);
-							found++;
+		spi_txrx(port);
+		tm_i2c_clear_oe(slot);
+		memcpy(newbuf, spi_getrxbuf(port)+4 + chip, 17*4);
+
+		d->job_switched = newbuf[16] != oldbuf[16];
+
+		int i;
+		int results_num = 0;
+		int found = 0;
+		unsigned * results = d->results;
+
+		d->old_nonce = 0;
+		d->future_nonce = 0;
+		for (i = 0; i < 16; i++) {
+			if (oldbuf[i] != newbuf[i] && op && o2p) {
+				unsigned pn; //possible nonce
+				unsigned int s = 0; //TODO zero may be solution
+				if ((newbuf[i] & 0xFF) == 0xE0)
+					continue;
+				pn = decnonce(newbuf[i]);
+				s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn) ? pn : 0;
+				s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn-0x00400000) ? pn - 0x00400000 : 0;
+				s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn-0x00800000) ? pn - 0x00800000 : 0;
+				s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn+0x02800000) ? pn + 0x02800000 : 0;
+				s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn+0x02C00000) ? pn + 0x02C00000 : 0;
+				s |= rehash(op->midstate, op->m7, op->ntime, op->nbits, pn+0x00400000) ? pn + 0x00400000 : 0;
+				if (s) {
+					int k;
+					int dup = 0;
+					for (k = 0; k < results_num; k++) {
+						if (results[k] == bswap_32(s)) {
+							dup = 1;
 						}
 					}
-
-					s = 0;
-					pn = decnonce(newbuf[i]);
-					s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn) ? pn : 0;
-					s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn-0x400000) ? pn - 0x400000 : 0;
-					s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn-0x800000) ? pn - 0x800000 : 0;
-					s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn+0x2800000)? pn + 0x2800000 : 0;
-					s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn+0x2C00000)? pn + 0x2C00000 : 0;
-					s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn+0x400000) ? pn + 0x400000 : 0;
-					if (s) {
-						d->old_nonce = bswap_32(s);
+					if (!dup) {
+						results[results_num++] = bswap_32(s);
 						found++;
 					}
+				}
 
-					s = 0;
-					pn = decnonce(newbuf[i]);
-					s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn) ? pn : 0;
-					s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn-0x400000) ? pn - 0x400000 : 0;
-					s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn-0x800000) ? pn - 0x800000 : 0;
-					s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn+0x2800000)? pn + 0x2800000 : 0;
-					s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn+0x2C00000)? pn + 0x2C00000 : 0;
-					s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn+0x400000) ? pn + 0x400000 : 0;
-					if (s) {
-						d->future_nonce = bswap_32(s);
-						found++;
-					}
-					if (!found) {
-						printf("AAA Strange: %08x, chip_id: %d\n", pn, chip_id);
-					}
+				s = 0;
+				pn = decnonce(newbuf[i]);
+				s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn) ? pn : 0;
+				s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn-0x400000) ? pn - 0x400000 : 0;
+				s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn-0x800000) ? pn - 0x800000 : 0;
+				s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn+0x2800000)? pn + 0x2800000 : 0;
+				s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn+0x2C00000)? pn + 0x2C00000 : 0;
+				s |= rehash(o2p->midstate, o2p->m7, o2p->ntime, o2p->nbits, pn+0x400000) ? pn + 0x400000 : 0;
+				if (s) {
+					d->old_nonce = bswap_32(s);
+					found++;
+				}
+
+				s = 0;
+				pn = decnonce(newbuf[i]);
+				s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn) ? pn : 0;
+				s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn-0x400000) ? pn - 0x400000 : 0;
+				s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn-0x800000) ? pn - 0x800000 : 0;
+				s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn+0x2800000)? pn + 0x2800000 : 0;
+				s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn+0x2C00000)? pn + 0x2C00000 : 0;
+				s |= rehash(p->midstate, p->m7, p->ntime, p->nbits, pn+0x400000) ? pn + 0x400000 : 0;
+				if (s) {
+					d->future_nonce = bswap_32(s);
+					found++;
+				}
+				if (!found) {
+					printf("AAA Strange: %08x, chip_id: %d\n", pn, chip_id);
 				}
 			}
-			d->results_n = results_num;
+		}
+		d->results_n = results_num;
 
+		if (smart) {
+			d_time = t_diff(d->timer2, d->timer1);
+		} else {
+			d_time = t_diff(d->otimer1, d->timer1);
+		}
+		d->ocounter1 = d->counter1;
+		d->counter1 = get_counter(newbuf, oldbuf);
+		if (d->counter2 || !smart) {
+			int shift;
+			int cycles;
+			int req1_cycles;
+			long long unsigned int period;
+			double ns;
+			unsigned full_cycles, half_cycles;
+			double full_delay, half_delay;
+			long long unsigned delta;
+			struct timespec t_delta;
+			double mhz;
+			int ccase;
+
+			shift = 800000;
 			if (smart) {
-				d_time = t_diff(d->timer2, d->timer1);
+				cycles = d->counter1 < d->counter2 ? 0x00400000 - d->counter2 + d->counter1 : d->counter1 - d->counter2; // + 0x003FFFFF;
 			} else {
-				d_time = t_diff(d->otimer1, d->timer1);
-			}
-			d->ocounter1 = d->counter1;
-			d->counter1 = get_counter(newbuf, oldbuf);
-			if (d->counter2 || !smart) {
-				int shift;
-				int cycles;
-				int req1_cycles;
-				long long unsigned int period;
-				double ns;
-				unsigned full_cycles, half_cycles;
-				double full_delay, half_delay;
-				long long unsigned delta;
-				struct timespec t_delta;
-				double mhz;
-				int ccase;
-
-				shift = 800000;
-				if (smart) {
-					cycles = d->counter1 < d->counter2 ? 0x00400000 - d->counter2 + d->counter1 : d->counter1 - d->counter2; // + 0x003FFFFF;
+				if (d->counter1 > (0x00400000 - shift * 2) && d->ocounter1 > (0x00400000 - shift)) {
+					cycles = 0x00400000 - d->ocounter1 + d->counter1; // + 0x003FFFFF;
+					ccase = 1;
 				} else {
-					if (d->counter1 > (0x00400000 - shift * 2) && d->ocounter1 > (0x00400000 - shift)) {
-						cycles = 0x00400000 - d->ocounter1 + d->counter1; // + 0x003FFFFF;
-						ccase = 1;
-					} else {
-						cycles = d->counter1 - d->ocounter1;
-						ccase = 2;
-					}
-				}
-				req1_cycles = 0x003FFFFF - d->counter1;
-				period = (long long unsigned int)d_time.tv_sec * 1000000000ULL + (long long unsigned int)d_time.tv_nsec;
-				ns = (double)period / (double)(cycles);
-				mhz = 1.0 / ns * 65.0 * 1000.0;
-
-				if (d->counter1 > 0 && d->counter1 < 0x001FFFFF)
-					printf("AAA chip_id %2d: %llu ms, req1_cycles: %08u,  counter1: %08d, ocounter1: %08d, counter2: %08d, cycles: %08d, ns: %.2f, mhz: %.2f \n", chip_id, period / 1000000ULL, req1_cycles, d->counter1, d->ocounter1, d->counter2, cycles, ns, mhz);
-				if (ns > 2000.0 || ns < 20) {
-					printf("AAA %d!Stupid ns chip_id %2d: %llu ms, req1_cycles: %08u,  counter1: %08d, ocounter1: %08d, counter2: %08d, cycles: %08d, ns: %.2f, mhz: %.2f \n", ccase, chip_id, period / 1000000ULL, req1_cycles, d->counter1, d->ocounter1, d->counter2, cycles, ns, mhz);
-					ns = 200.0;
-				} else {
-					d->ns = ns;
-					d->mhz = mhz;
+					cycles = d->counter1 - d->ocounter1;
+					ccase = 2;
 				}
+			}
+			req1_cycles = 0x003FFFFF - d->counter1;
+			period = (long long unsigned int)d_time.tv_sec * 1000000000ULL + (long long unsigned int)d_time.tv_nsec;
+			ns = (double)period / (double)(cycles);
+			mhz = 1.0 / ns * 65.0 * 1000.0;
+
+			if (d->counter1 > 0 && d->counter1 < 0x001FFFFF)
+				printf("AAA chip_id %2d: %llu ms, req1_cycles: %08u,  counter1: %08d, ocounter1: %08d, counter2: %08d, cycles: %08d, ns: %.2f, mhz: %.2f \n", chip_id, period / 1000000ULL, req1_cycles, d->counter1, d->ocounter1, d->counter2, cycles, ns, mhz);
+			if (ns > 2000.0 || ns < 20) {
+				printf("AAA %d!Stupid ns chip_id %2d: %llu ms, req1_cycles: %08u,  counter1: %08d, ocounter1: %08d, counter2: %08d, cycles: %08d, ns: %.2f, mhz: %.2f \n", ccase, chip_id, period / 1000000ULL, req1_cycles, d->counter1, d->ocounter1, d->counter2, cycles, ns, mhz);
+				ns = 200.0;
+			} else {
+				d->ns = ns;
+				d->mhz = mhz;
+			}
 
-				if (smart) {
-					half_cycles = req1_cycles + shift;
-					full_cycles = 0x003FFFFF - 2 * shift;
-				} else {
-					half_cycles = 0;
-					full_cycles = req1_cycles > shift ? req1_cycles - shift : req1_cycles + 0x00400000 - shift;
-				}
-				half_delay = (double)half_cycles * ns * (1 +0.92);
-				full_delay = (double)full_cycles * ns;
-				delta = (long long unsigned)(full_delay + half_delay);
-				t_delta.tv_sec = delta / 1000000000ULL;
-				t_delta.tv_nsec = delta - t_delta.tv_sec * 1000000000ULL;
-				d->predict1 = t_add(time, t_delta);
-
-				if (smart) {
-					half_cycles = req1_cycles + shift;
-					full_cycles = 0;
-				} else {
-					full_cycles = req1_cycles + shift;
-				}
-				half_delay = (double)half_cycles * ns * (1 + 0.92);
-				full_delay = (double)full_cycles * ns;
-				delta = (long long unsigned)(full_delay + half_delay);
-
-				t_delta.tv_sec = delta / 1000000000ULL;
-				t_delta.tv_nsec = delta - t_delta.tv_sec * 1000000000ULL;
-				d->predict2 = t_add(time, t_delta);
-				d->req2_done = 0; d->req1_done = 0;
+			if (smart) {
+				half_cycles = req1_cycles + shift;
+				full_cycles = 0x003FFFFF - 2 * shift;
+			} else {
+				half_cycles = 0;
+				full_cycles = req1_cycles > shift ? req1_cycles - shift : req1_cycles + 0x00400000 - shift;
 			}
+			half_delay = (double)half_cycles * ns * (1 +0.92);
+			full_delay = (double)full_cycles * ns;
+			delta = (long long unsigned)(full_delay + half_delay);
+			t_delta.tv_sec = delta / 1000000000ULL;
+			t_delta.tv_nsec = delta - t_delta.tv_sec * 1000000000ULL;
+			d->predict1 = t_add(time, t_delta);
 
-			if (d->job_switched) {
-				memcpy(o2p, op, sizeof(struct bitfury_payload));
-				memcpy(op, p, sizeof(struct bitfury_payload));
-				memcpy(oldbuf, newbuf, 17 * 4);
+			if (smart) {
+				half_cycles = req1_cycles + shift;
+				full_cycles = 0;
+			} else {
+				full_cycles = req1_cycles + shift;
 			}
+			half_delay = (double)half_cycles * ns * (1 + 0.92);
+			full_delay = (double)full_cycles * ns;
+			delta = (long long unsigned)(full_delay + half_delay);
+
+			t_delta.tv_sec = delta / 1000000000ULL;
+			t_delta.tv_nsec = delta - t_delta.tv_sec * 1000000000ULL;
+			d->predict2 = t_add(time, t_delta);
+			d->req2_done = 0; d->req1_done = 0;
 		}
 
-		clock_gettime(CLOCK_REALTIME, &(time));
-		d_time = t_diff(time, d->predict2);
-		if (d_time.tv_sec < 0 && !d->req2_done) {
-			if(smart) {
-				d->otimer2 = d->timer2;
-				d->timer2 = time;
-				spi_clear_buf(port);
-				spi_emit_break(port);
-				spi_emit_fasync(port, chip);
-				spi_emit_data(port, 0x3000, &atrvec[0], 19*4);
-				if (smart) {
-					config_reg(port, 3, 1);
-				}
-				tm_i2c_set_oe(slot);
-				spi_txrx(port);
-				tm_i2c_clear_oe(slot);
-				memcpy(newbuf, spi_getrxbuf(port)+4 + chip, 17*4);
-				d->counter2 = get_counter(newbuf, oldbuf);
+		if (d->job_switched) {
+			memcpy(o2p, op, sizeof(struct bitfury_payload));
+			memcpy(op, p, sizeof(struct bitfury_payload));
+			memcpy(oldbuf, newbuf, 17 * 4);
+		}
+	}
 
-				d->req2_done = 1;
-			} else {
-				d->req2_done = 1;
+	clock_gettime(CLOCK_REALTIME, &(time));
+	d_time = t_diff(time, d->predict2);
+	if (d_time.tv_sec < 0 && !d->req2_done) {
+		if(smart) {
+			d->otimer2 = d->timer2;
+			d->timer2 = time;
+			spi_clear_buf(port);
+			spi_emit_break(port);
+			spi_emit_fasync(port, chip);
+			spi_emit_data(port, 0x3000, &atrvec[0], 19*4);
+			if (smart) {
+				config_reg(port, 3, 1);
 			}
+			tm_i2c_set_oe(slot);
+			spi_txrx(port);
+			tm_i2c_clear_oe(slot);
+			memcpy(newbuf, spi_getrxbuf(port)+4 + chip, 17*4);
+			d->counter2 = get_counter(newbuf, oldbuf);
+
+			d->req2_done = 1;
+		} else {
+			d->req2_done = 1;
 		}
 	}
-	second_run = 1;
+}
+
+void libbitfury_sendHashData(struct bitfury_device *bf, int chip_n) {
+	int chip_id;
+	static bool second_run = false;
+
+	for (chip_id = 0; chip_id < chip_n; chip_id++) {
+		struct bitfury_device *d = bf + chip_id;
+		libbitfury_sendHashData1(chip_id, d, second_run);
+	}
+	second_run = true;
 
 	return;
 }

libbitfury.h

@@ -52,11 +52,13 @@ struct bitfury_device {
 };
 
 int libbitfury_readHashData(unsigned int *res);
+extern void libbitfury_sendHashData1(int chip_id, struct bitfury_device *d, bool second_run);
 void libbitfury_sendHashData(struct bitfury_device *bf, int chip_n);
 void work_to_payload(struct bitfury_payload *p, struct work *w);
 struct timespec t_diff(struct timespec start, struct timespec end);
 extern void send_reinit(struct spi_port *, int slot, int chip_n, int n);
 extern void send_freq(struct spi_port *, int slot, int chip_n, int bits);
+extern int libbitfury_detectChips1(struct spi_port *);
 extern int libbitfury_detectChips(struct spi_port *, struct bitfury_device *devices);
 void libbitfury_shutdownChips(struct bitfury_device *devices, int chip_n);
 

spidevc.h

@@ -16,6 +16,10 @@ struct spi_port {
 	
 	char spibuf[SPIMAXSZ], spibuf_rx[SPIMAXSZ];
 	size_t spibufsz;
+	
+	struct cgpu_info *cgpu;
+	const char *repr;
+	int logprio;
 };
 
 extern struct spi_port *sys_spi;