bfgminer/driver-bab.c

/*
 * Copyright 2013 Andrew Smith
 * Copyright 2013 bitfury
 *
 * BitFury GPIO code based on chainminer code:
 *	https://github.com/bfsb/chainminer
 *
 * 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 "compat.h"
#include "miner.h"
#include "sha2.h"

/*
 * Tested on RPi running Raspbian with BlackArrow BitFury V1 16 chip GPIO board
 */

#ifndef LINUX
static void bab_detect(__maybe_unused bool hotplug)
{
}
#else

#include <unistd.h>
#include <linux/spi/spidev.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <fcntl.h>

#define BAB_SPI_BUS 0
#define BAB_SPI_CHIP 0

#define BAB_SPI_SPEED 96000
#define BAB_SPI_BUFSIZ 1024

#define BAB_ADDR(_n) (*((babinfo->gpio) + (_n)))

#define BAB_INP_GPIO(_n) BAB_ADDR((_n) / 10) &= (~(7 << (((_n) % 10) * 3)))
#define BAB_OUT_GPIO(_n) BAB_ADDR((_n) / 10) |= (1 << (((_n) % 10) * 3))
#define BAB_OUT_GPIO_V(_n, _v) BAB_ADDR((_n) / 10) |= (((_v) <= 3 ? (_v) + 4 : \
					((_v) == 4 ? 3 : 2)) << (((_n) % 10) * 3))

#define BAB_GPIO_SET BAB_ADDR(7)
#define BAB_GPIO_CLR BAB_ADDR(10)
#define BAB_GPIO_LEVEL BAB_ADDR(13)

#define BAB_MAXCHIPS 256
#define BAB_MAXBUF (BAB_MAXCHIPS * 512)
#define BAB_MAXBANKS 4
#define BAB_CORES 16
#define BAB_X_COORD 21
#define BAB_Y_COORD 36

#define BAB_BREAK ((uint8_t *)"\04")
#define BAB_ASYNC ((uint8_t *)"\05")
#define BAB_SYNC ((uint8_t *)"\06")

#define BAB_FFL " - from %s %s() line %d"
#define BAB_FFL_HERE __FILE__, __func__, __LINE__
#define BAB_FFL_PASS file, func, line

#define bab_reset(_bank, _times) _bab_reset(babcgpu, babinfo, _bank, _times)
#define bab_txrx(_buf, _siz, _det) _bab_txrx(babcgpu, babinfo, _buf, _siz, _det, BAB_FFL_HERE)
#define bab_add_buf(_data) _bab_add_buf(babcgpu, babinfo, _data, sizeof(_data)-1, BAB_FFL_HERE)
#define BAB_ADD_BREAK() _bab_add_buf(babcgpu, babinfo, BAB_BREAK, 1, BAB_FFL_HERE)
#define BAB_ADD_ASYNC() _bab_add_buf(babcgpu, babinfo, BAB_ASYNC, 1, BAB_FFL_HERE)
#define bab_config_reg(_reg, _ena) _bab_config_reg(babcgpu, babinfo, _reg, _ena, BAB_FFL_HERE)
#define bab_add_data(_addr, _data, _siz) _bab_add_data(babcgpu, babinfo, _addr, (const uint8_t *)(_data), _siz, BAB_FFL_HERE)

#define BAB_ADD_MIN 4
#define BAB_ADD_MAX 128

#define BAB_STATE_DONE 0
#define BAB_STATE_READY 1
#define BAB_STATE_SENDING 2
#define BAB_STATE_SENT 3
#define BAB_STATE_READING 4

#define BAB_SPI_BUFFERS 2

#define BAB_BASEA 4
#define BAB_BASEB 61
#define BAB_COUNTERS 16
static const uint8_t bab_counters[BAB_COUNTERS] = {
	64,			64,
	BAB_BASEA,		BAB_BASEA+4,
	BAB_BASEA+2,		BAB_BASEA+2+16,
	BAB_BASEA,		BAB_BASEA+1,
	(BAB_BASEB)%65,		(BAB_BASEB+1)%65,
	(BAB_BASEB+3)%65,	(BAB_BASEB+3+16)%65,
	(BAB_BASEB+4)%65,	(BAB_BASEB+4+4)%65,
	(BAB_BASEB+3+3)%65,	(BAB_BASEB+3+1+3)%65
};

#define BAB_W1 16
static const uint32_t bab_w1[BAB_W1] = {
	0,		0,	0,	0xffffffff,
	0x80000000,	0,	0,	0,
	0,		0,	0,	0,
	0,		0,	0,	0x00000280
};

#define BAB_W2 8
static const uint32_t bab_w2[BAB_W2] = {
	0x80000000,	0,	0,	0,
	0,		0,	0,	0x00000100
};

#define BAB_TEST_DATA 19
static const uint32_t bab_test_data[BAB_TEST_DATA] = {
	0xb0e72d8e,	0x1dc5b862,	0xe9e7c4a6,	0x3050f1f5,
	0x8a1a6b7e,	0x7ec384e8,	0x42c1c3fc,	0x8ed158a1,
	0x8a1a6b7e,	0x6f484872,	0x4ff0bb9b,	0x12c97f07,
	0xb0e72d8e,	0x55d979bc,	0x39403296,	0x40f09e84,
	0x8a0bb7b7,	0x33af304f,	0x0b290c1a //,	0xf0c4e61f
};

//maximum number of chips on alternative bank
// #define BANKCHIPS 64

/*
 * maximum chip speed available for auto tuner
 * speed/nrate/hrate/watt
 *    53/   97/  100/  84
 *    54/   98/  107/  88
 *    55/   99/  115/  93
 *    56/  101/  125/  99
 */
#define BAB_MAXSPEED 57
#define BAB_DEFSPEED 54
#define BAB_MINSPEED 52

#define MIDSTATE_BYTES 32
#define MERKLE_OFFSET 64
#define MERKLE_BYTES 12
#define BLOCK_HEADER_BYTES 80

#define MIDSTATE_UINTS (MIDSTATE_BYTES / sizeof(uint32_t))
#define DATA_UINTS ((BLOCK_HEADER_BYTES / sizeof(uint32_t)) - 1)

// Auto adjust
#define BAB_AUTO_REG 0
#define BAB_AUTO_VAL 0x01
// iclk
#define BAB_ICLK_REG 1
#define BAB_ICLK_VAL 0x02
// No fast clock
#define BAB_FAST_REG 2
#define BAB_FAST_VAL 0x04
// Divide by 2
#define BAB_DIV2_REG 3
#define BAB_DIV2_VAL 0x08
// Slow Clock
#define BAB_SLOW_REG 4
#define BAB_SLOW_VAL 0x10
// No oclk
#define BAB_OCLK_REG 6
#define BAB_OCLK_VAL 0x20
// Has configured
#define BAB_CFGD_VAL 0x40

#define BAB_DEFCONF (BAB_AUTO_VAL | \
		     BAB_ICLK_VAL | \
		     BAB_DIV2_VAL | \
		     BAB_SLOW_VAL)

#define BAB_REG_CLR_FROM 7
#define BAB_REG_CLR_TO 11

#define BAB_AUTO_SET(_c) ((_c) & BAB_AUTO_VAL)
#define BAB_ICLK_SET(_c) ((_c) & BAB_ICLK_VAL)
#define BAB_FAST_SET(_c) ((_c) & BAB_FAST_VAL)
#define BAB_DIV2_SET(_c) ((_c) & BAB_DIV2_VAL)
#define BAB_SLOW_SET(_c) ((_c) & BAB_SLOW_VAL)
#define BAB_OCLK_SET(_c) ((_c) & BAB_OCLK_VAL)
#define BAB_CFGD_SET(_c) ((_c) & BAB_CFGD_VAL)

#define BAB_AUTO_BIT(_c) (BAB_AUTO_SET(_c) ? true : false)
#define BAB_ICLK_BIT(_c) (BAB_ICLK_SET(_c) ? false : true)
#define BAB_FAST_BIT(_c) (BAB_FAST_SET(_c) ? true : false)
#define BAB_DIV2_BIT(_c) (BAB_DIV2_SET(_c) ? false : true)
#define BAB_SLOW_BIT(_c) (BAB_SLOW_SET(_c) ? true : false)
#define BAB_OCLK_BIT(_c) (BAB_OCLK_SET(_c) ? true : false)

#define BAB_COUNT_ADDR 0x0100
#define BAB_W1A_ADDR 0x1000
#define BAB_W1B_ADDR 0x1400
#define BAB_W2_ADDR 0x1900
#define BAB_INP_ADDR 0x3000
#define BAB_OSC_ADDR 0x6000
#define BAB_REG_ADDR 0x7000

/*
 * valid: 0x01 0x03 0x07 0x0F 0x1F 0x3F 0x7F 0xFF
 * max { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x00 }
 * max { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00 }
 * avg { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00 }
 * slo { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00 }
 * min { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
 * good: 0x1F (97) 0x3F (104) 0x7F (109) 0xFF (104)
 */

#define BAB_OSC 8
static const uint8_t bab_osc_bits[BAB_OSC] =
	{ 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF };

static const uint8_t bab_reg_ena[4] = { 0xc1, 0x6a, 0x59, 0xe3 };
static const uint8_t bab_reg_dis[4] = { 0x00, 0x00, 0x00, 0x00 };

#define BAB_NONCE_OFFSETS 3
static const uint32_t bab_nonce_offsets[] = {-0x800000, 0, -0x400000};

struct bab_work_send {
	uint32_t midstate[MIDSTATE_UINTS];
	uint32_t ms3steps[MIDSTATE_UINTS];
	uint32_t merkle7;
	uint32_t ntime;
	uint32_t bits;
};

#define BAB_REPLY_NONCES 16
struct bab_work_reply {
	uint32_t nonce[BAB_REPLY_NONCES];
	uint32_t jobsel;
};

#define MAX_BLISTS 4096

typedef struct blist {
	struct blist *prev;
	struct blist *next;
	struct work *work;
	int nonces;
} BLIST;

#define MAX_RLISTS 256

typedef struct rlist {
	struct rlist *prev;
	struct rlist *next;
	int chip;
	uint32_t nonce;
	bool first_second;
} RLIST;

struct bab_info {
	struct thr_info spi_thr;
	struct thr_info res_thr;

	pthread_mutex_t spi_lock;
	pthread_mutex_t res_lock;
	pthread_mutex_t did_lock;
	cglock_t blist_lock;

	// All GPIO goes through this
	volatile unsigned *gpio;

	int spifd;
	int chips;
	uint32_t chip_spis[BAB_MAXCHIPS+1];

	int buffer;
	int buf_status[BAB_SPI_BUFFERS];
	uint8_t buf_write[BAB_SPI_BUFFERS][BAB_MAXBUF];
	uint8_t buf_read[BAB_SPI_BUFFERS][BAB_MAXBUF];
	uint32_t buf_used[BAB_SPI_BUFFERS];
	uint32_t chip_off[BAB_SPI_BUFFERS][BAB_MAXCHIPS+1];
	uint32_t bank_off[BAB_SPI_BUFFERS][BAB_MAXBANKS+2];

	struct bab_work_send chip_input[BAB_MAXCHIPS];
	struct bab_work_reply chip_results[BAB_MAXCHIPS];
	struct bab_work_reply chip_prev[BAB_MAXCHIPS];

	uint8_t chip_fast[BAB_MAXCHIPS];
	uint8_t chip_conf[BAB_MAXCHIPS];
	uint8_t old_fast[BAB_MAXCHIPS];
	uint8_t old_conf[BAB_MAXCHIPS];
	uint8_t chip_bank[BAB_MAXCHIPS+1];

	uint8_t osc[BAB_OSC];

	int fixchip;

	/*
	 * Ignore errors in the first work reply since
	 * they may be from a previous run or random junk
	 * There can be >100 with just a 16 chip board
	 */
	uint32_t initial_ignored;
	bool nonce_before[BAB_MAXCHIPS];
	bool not_first_reply[BAB_MAXCHIPS];

	// Stats
	struct timeval chip_start[BAB_MAXCHIPS];
	int chip_busy[BAB_MAXCHIPS];
	uint64_t core_good[BAB_MAXCHIPS][BAB_CORES];
	uint64_t core_bad[BAB_MAXCHIPS][BAB_CORES];
	uint64_t chip_spie[BAB_MAXCHIPS]; // spi errors
	uint64_t chip_miso[BAB_MAXCHIPS]; // msio errors
	uint64_t chip_nonces[BAB_MAXCHIPS];
	uint64_t chip_good[BAB_MAXCHIPS];
	uint64_t chip_bad[BAB_MAXCHIPS];
	uint64_t chip_ncore[BAB_MAXCHIPS][BAB_X_COORD][BAB_Y_COORD];

	uint64_t untested_nonces;
	uint64_t tested_nonces;

	uint64_t new_nonces;
	uint64_t ok_nonces;

	uint64_t nonce_offset_count[BAB_NONCE_OFFSETS];
	uint64_t total_tests;
	uint64_t max_tests_per_nonce;
	uint64_t total_links;
	uint64_t max_links;

	int blist_count;
	int bfree_count;
	int work_count;
	int chip_count;
	BLIST *bfree_list;
	BLIST *work_list;
	BLIST *chip_list[BAB_MAXCHIPS];

	int rlist_count;
	int rfree_count;
	int res_count;
	RLIST *rfree_list;
	RLIST *res_list_head;
	RLIST *res_list_tail;

	struct timeval last_did;

	bool initialised;
};

static BLIST *new_blist_set(struct cgpu_info *babcgpu)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	BLIST *blist = NULL;
	int i;

	blist = calloc(MAX_BLISTS, sizeof(*blist));
	if (!blist)
		quithere(1, "Failed to calloc blist - when old count=%d", babinfo->blist_count);

	babinfo->blist_count += MAX_BLISTS;
	babinfo->bfree_count = MAX_BLISTS;

	blist[0].prev = NULL;
	blist[0].next = &(blist[1]);
	for (i = 1; i < MAX_BLISTS-1; i++) {
		blist[i].prev = &blist[i-1];
		blist[i].next = &blist[i+1];
	}
	blist[MAX_BLISTS-1].prev = &(blist[MAX_BLISTS-2]);
	blist[MAX_BLISTS-1].next = NULL;

	return blist;
}

static BLIST *next_work(struct cgpu_info *babcgpu, int chip)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	BLIST *bitem;

	cg_wlock(&babinfo->blist_lock);
	bitem = babinfo->work_list;
	if (bitem) {
		// Unlink it from work
		if (bitem->next)
			bitem->next->prev = NULL;
		babinfo->work_list = bitem->next;
		babinfo->work_count--;

		// Add it to the chip
		bitem->next = babinfo->chip_list[chip];
		bitem->prev = NULL;
		if (bitem->next)
			bitem->next->prev = bitem;
		babinfo->chip_list[chip] = bitem;
		babinfo->chip_count++;
	}
	cg_wunlock(&babinfo->blist_lock);

	return bitem;
}

static void discard_last(struct cgpu_info *babcgpu, int chip)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	BLIST *bitem;

	cg_wlock(&babinfo->blist_lock);
	bitem = babinfo->chip_list[chip];
	if (bitem) {
		// Unlink it from the chip
		if (bitem->next)
			bitem->next->prev = NULL;
		babinfo->chip_list[chip] = bitem->next;
		babinfo->chip_count--;

		// Put it in the free list
		bitem->next = babinfo->bfree_list;
		bitem->prev = NULL;
		if (bitem->next)
			bitem->next->prev = bitem;
		babinfo->bfree_list = bitem;
		babinfo->bfree_count++;
	}
	cg_wunlock(&babinfo->blist_lock);
}

static BLIST *store_work(struct cgpu_info *babcgpu, struct work *work)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	BLIST *bitem = NULL;
	int ran_out = 0;

	cg_wlock(&babinfo->blist_lock);

	if (babinfo->bfree_list == NULL) {
		ran_out = babinfo->blist_count;
		babinfo->bfree_list = new_blist_set(babcgpu);
	}

	// unlink from free
	bitem = babinfo->bfree_list;
	babinfo->bfree_list = babinfo->bfree_list->next;
	if (babinfo->bfree_list)
		babinfo->bfree_list->prev = NULL;
	babinfo->bfree_count--;

	// add to work
	bitem->next = babinfo->work_list;
	bitem->prev = NULL;
	if (bitem->next)
		bitem->next->prev = bitem;
	babinfo->work_list = bitem;
	babinfo->work_count++;

	bitem->work = work;
	bitem->nonces = 0;

	cg_wunlock(&babinfo->blist_lock);

	if (ran_out > 0) {
		applog(LOG_ERR, "%s%i: BLIST used count exceeded %d, now %d (work=%d chip=%d)",
				babcgpu->drv->name, babcgpu->device_id,
				ran_out, babinfo->blist_count,
				babinfo->work_count,
				babinfo->chip_count);
	}

	return bitem;
}

static void free_blist(struct cgpu_info *babcgpu, BLIST *bhead, int chip)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	struct work *work;
	BLIST *bitem;

	if (!bhead)
		return;

	// Unlink it from the chip
	cg_wlock(&babinfo->blist_lock);
	if (unlikely(bhead == babinfo->chip_list[chip])) {
		// Removing the chip head is an error
		bhead = bhead->next;
		babinfo->chip_list[chip]->next = NULL;
	} else
		bhead->prev->next = NULL;
	bitem = bhead;
	while (bitem) {
		babinfo->chip_count--;
		bitem = bitem->next;
	}
	cg_wunlock(&babinfo->blist_lock);

	while (bhead) {
		bitem = bhead;
		bhead = bitem->next;

		// add to free
		cg_wlock(&babinfo->blist_lock);
		bitem->next = babinfo->bfree_list;
		if (babinfo->bfree_list)
			babinfo->bfree_list->prev = bitem;
		bitem->prev = NULL;
		babinfo->bfree_list = bitem;
		babinfo->bfree_count++;
		work = bitem->work;
		cg_wunlock(&babinfo->blist_lock);

		work_completed(babcgpu, work);
	}

}

static RLIST *new_rlist_set(struct cgpu_info *babcgpu)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	RLIST *rlist = NULL;
	int i;

	rlist = calloc(MAX_RLISTS, sizeof(*rlist));
	if (!rlist)
		quithere(1, "Failed to calloc rlist - when old count=%d", babinfo->rlist_count);

	babinfo->rlist_count += MAX_RLISTS;
	babinfo->rfree_count = MAX_RLISTS;

	rlist[0].prev = NULL;
	rlist[0].next = &(rlist[1]);
	for (i = 1; i < MAX_RLISTS-1; i++) {
		rlist[i].prev = &rlist[i-1];
		rlist[i].next = &rlist[i+1];
	}
	rlist[MAX_RLISTS-1].prev = &(rlist[MAX_RLISTS-2]);
	rlist[MAX_RLISTS-1].next = NULL;

	return rlist;
}

static RLIST *store_nonce(struct cgpu_info *babcgpu, int chip, uint32_t nonce, bool first_second)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	RLIST *ritem = NULL;
	int ran_out = 0;

	mutex_lock(&(babinfo->res_lock));

	if (babinfo->rfree_list == NULL) {
		ran_out = babinfo->rlist_count;
		babinfo->rfree_list = new_rlist_set(babcgpu);
	}

	// unlink from rfree
	ritem = babinfo->rfree_list;
	babinfo->rfree_list = babinfo->rfree_list->next;
	if (babinfo->rfree_list)
		babinfo->rfree_list->prev = NULL;
	babinfo->rfree_count--;

	// add to head of results
	ritem->next = babinfo->res_list_head;
	ritem->prev = NULL;
	babinfo->res_list_head = ritem;
	if (ritem->next)
		ritem->next->prev = ritem;
	else
		babinfo->res_list_tail = ritem;

	babinfo->res_count++;

	ritem->chip = chip;
	ritem->nonce = nonce;
	ritem->first_second = first_second;

	mutex_unlock(&(babinfo->res_lock));

	if (ran_out > 0) {
		applog(LOG_ERR, "%s%i: RLIST used count exceeded %d, now %d (work=%d chip=%d)",
				babcgpu->drv->name, babcgpu->device_id,
				ran_out, babinfo->rlist_count,
				babinfo->work_count,
				babinfo->chip_count);
	}

	return ritem;
}

static bool oldest_nonce(struct cgpu_info *babcgpu, int *chip, uint32_t *nonce, bool *first_second)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	RLIST *ritem = NULL;
	bool found = false;

	mutex_lock(&(babinfo->res_lock));

	if (babinfo->res_list_tail) {
		// unlink from res
		ritem = babinfo->res_list_tail;
		if (ritem->prev) {
			ritem->prev->next = NULL;
			babinfo->res_list_tail = ritem->prev;
		} else
			babinfo->res_list_head = babinfo->res_list_tail = NULL;

		babinfo->res_count--;

		found = true;
		*chip = ritem->chip;
		*nonce = ritem->nonce;
		*first_second = ritem->first_second;

		// add to rfree
		ritem->next = babinfo->rfree_list;
		ritem->prev = NULL;
		if (ritem->next)
			ritem->next->prev = ritem;
		babinfo->rfree_list = ritem;

		babinfo->rfree_count++;
	}

	mutex_unlock(&(babinfo->res_lock));

	return found;
}

static void _bab_reset(__maybe_unused struct cgpu_info *babcgpu, struct bab_info *babinfo, int bank, int times)
{
	const int banks[4] = { 18, 23, 24, 25 };
	int i;

	BAB_INP_GPIO(10);
	BAB_OUT_GPIO(10);
	BAB_INP_GPIO(11);
	BAB_OUT_GPIO(11);

	if (bank) {
		for (i = 0; i < 4; i++) {
			BAB_INP_GPIO(banks[i]);
			BAB_OUT_GPIO(banks[i]);
			if (bank == i+1)
				BAB_GPIO_SET = 1 << banks[i];
			else
				BAB_GPIO_CLR = 1 << banks[i];
		}
		cgsleep_us(4096);
	} else {
		for (i = 0; i < 4; i++)
			BAB_INP_GPIO(banks[i]);
	}

	BAB_GPIO_SET = 1 << 11;
	for (i = 0; i < times; i++) { // 1us = 1MHz
		BAB_GPIO_SET = 1 << 10;
		cgsleep_us(1);
		BAB_GPIO_CLR = 1 << 10;
		cgsleep_us(1);
	}
	BAB_GPIO_CLR = 1 << 11;
	BAB_INP_GPIO(11);
	BAB_INP_GPIO(10);
	BAB_INP_GPIO(9);
	BAB_OUT_GPIO_V(11, 0);
	BAB_OUT_GPIO_V(10, 0);
	BAB_OUT_GPIO_V(9, 0);
}

// TODO: handle a false return where this is called?
static bool _bab_txrx(struct cgpu_info *babcgpu, struct bab_info *babinfo, int buf, uint32_t siz, bool detect_ignore, const char *file, const char *func, const int line)
{
	int bank, i;
	uint32_t pos;
	struct spi_ioc_transfer tran;
	uintptr_t rbuf, wbuf;

	wbuf = (uintptr_t)(babinfo->buf_write[buf]);
	rbuf = (uintptr_t)(babinfo->buf_read[buf]);

	memset(&tran, 0, sizeof(tran));
	tran.delay_usecs = 0;
	tran.speed_hz = BAB_SPI_SPEED;

	i = 0;
	pos = 0;
	for (bank = 0; bank <= BAB_MAXBANKS; bank++) {
		if (babinfo->bank_off[buf][bank]) {
			bab_reset(bank, 64);
			break;
		}
	}

	if (unlikely(bank > BAB_MAXBANKS)) {
		applog(LOG_ERR, "%s%d: %s() failed to find a bank" BAB_FFL,
				babcgpu->drv->name, babcgpu->device_id,
				__func__, BAB_FFL_PASS);
		return false;
	}

	while (siz > 0) {
		tran.tx_buf = wbuf;
		tran.rx_buf = rbuf;
		tran.speed_hz = BAB_SPI_SPEED;
		if (pos == babinfo->bank_off[buf][bank]) {
			for (; ++bank <= BAB_MAXBANKS; ) {
				if (babinfo->bank_off[buf][bank] > pos) {
					bab_reset(bank, 64);
					break;
				}
			}
		}
		if (siz < BAB_SPI_BUFSIZ)
			tran.len = siz;
		else
			tran.len = BAB_SPI_BUFSIZ;

		if (pos < babinfo->bank_off[buf][bank] &&
		    babinfo->bank_off[buf][bank] < (pos + tran.len))
			tran.len = babinfo->bank_off[buf][bank] - pos;

		for (; i < babinfo->chips; i++) {
			if (!babinfo->chip_off[buf][i])
				continue;
			if (babinfo->chip_off[buf][i] >= pos + tran.len) {
				tran.speed_hz = babinfo->chip_spis[i];
				break;
			}
		}

		if (unlikely(i > babinfo->chips)) {
			applog(LOG_ERR, "%s%d: %s() failed to find chip" BAB_FFL,
					babcgpu->drv->name, babcgpu->device_id,
					__func__, BAB_FFL_PASS);
			return false;
		}

		if (unlikely(babinfo->chip_spis[i] == BAB_SPI_SPEED)) {
			applog(LOG_DEBUG, "%s%d: %s() chip[%d] speed %d shouldn't be %d" BAB_FFL,
						babcgpu->drv->name, babcgpu->device_id,
						__func__, i, (int)babinfo->chip_spis[i],
						BAB_SPI_SPEED, BAB_FFL_PASS);
		}

		if (unlikely(tran.speed_hz == BAB_SPI_SPEED)) {
			applog(LOG_DEBUG, "%s%d: %s() transfer speed %d shouldn't be %d" BAB_FFL,
						babcgpu->drv->name, babcgpu->device_id,
						__func__, (int)tran.speed_hz,
						BAB_SPI_SPEED, BAB_FFL_PASS);
		}

		if (ioctl(babinfo->spifd, SPI_IOC_MESSAGE(1), (void *)&tran) < 0) {
			if (!detect_ignore || errno != 110) {
				applog(LOG_ERR, "%s%d: ioctl failed err=%d" BAB_FFL,
						babcgpu->drv->name, babcgpu->device_id,
						errno, BAB_FFL_PASS);
			}
			return false;
		}

		siz -= tran.len;
		wbuf += tran.len;
		rbuf += tran.len;
		pos += tran.len;
	}
	mutex_lock(&(babinfo->did_lock));
	cgtime(&(babinfo->last_did));
	mutex_unlock(&(babinfo->did_lock));
	return true;
}

static void _bab_add_buf_rev(__maybe_unused struct cgpu_info *babcgpu, struct bab_info *babinfo, const uint8_t *data, uint32_t siz, const char *file, const char *func, const int line)
{
	uint8_t tmp;
	uint32_t now_used, i;
	int buf;

	buf = babinfo->buffer;
	now_used = babinfo->buf_used[buf];
	if (now_used + siz >= BAB_MAXBUF) {
		quitfrom(1, file, func, line,
			"%s() buffer %d limit of %d exceeded=%d siz=%d",
			__func__, buf, BAB_MAXBUF, now_used + siz, siz);
	}

	for (i = 0; i < siz; i++) {
		tmp = data[i];
		tmp = ((tmp & 0xaa)>>1) | ((tmp & 0x55) << 1);
		tmp = ((tmp & 0xcc)>>2) | ((tmp & 0x33) << 2);
		tmp = ((tmp & 0xf0)>>4) | ((tmp & 0x0f) << 4);
		babinfo->buf_write[buf][now_used + i] = tmp;
	}

	babinfo->buf_used[buf] += siz;
}

static void _bab_add_buf(__maybe_unused struct cgpu_info *babcgpu, struct bab_info *babinfo, const uint8_t *data, size_t siz, const char *file, const char *func, const int line)
{
	uint32_t now_used;
	int buf;

	buf = babinfo->buffer;
	now_used = babinfo->buf_used[buf];
	if (now_used + siz >= BAB_MAXBUF) {
		quitfrom(1, file, func, line,
			"%s() buffer %d limit of %d exceeded=%d siz=%d",
			__func__, buf, BAB_MAXBUF, (int)(now_used + siz), (int)siz);
	}

	memcpy(&(babinfo->buf_write[buf][now_used]), data, siz);
	babinfo->buf_used[buf] += siz;
}

static void _bab_add_data(struct cgpu_info *babcgpu, struct bab_info *babinfo, uint32_t addr, const uint8_t *data, size_t siz, const char *file, const char *func, const int line)
{
	uint8_t tmp[3];
	int trf_siz;

	if (siz < BAB_ADD_MIN || siz > BAB_ADD_MAX) {
		quitfrom(1, file, func, line,
			"%s() called with invalid siz=%d (min=%d max=%d)",
			__func__, (int)siz, BAB_ADD_MIN, BAB_ADD_MAX);
	}
	trf_siz = siz / 4;
	tmp[0] = (trf_siz - 1) | 0xE0;
	tmp[1] = (addr >> 8) & 0xff;
	tmp[2] = addr & 0xff;
	_bab_add_buf(babcgpu, babinfo, tmp, sizeof(tmp), BAB_FFL_PASS);
	_bab_add_buf_rev(babcgpu, babinfo, data, siz, BAB_FFL_PASS);
}

static void _bab_config_reg(struct cgpu_info *babcgpu, struct bab_info *babinfo, uint32_t reg, bool enable, const char *file, const char *func, const int line)
{
	if (enable) {
		_bab_add_data(babcgpu, babinfo, BAB_REG_ADDR + reg*32,
				bab_reg_ena, sizeof(bab_reg_ena), BAB_FFL_PASS);
	} else {
		_bab_add_data(babcgpu, babinfo, BAB_REG_ADDR + reg*32,
				bab_reg_dis, sizeof(bab_reg_dis), BAB_FFL_PASS);
	}

}

static void bab_set_osc(struct bab_info *babinfo, int chip)
{
	int fast, i;

	fast = babinfo->chip_fast[chip];

	for (i = 0; i < BAB_OSC && fast > BAB_OSC; i++, fast -= BAB_OSC) {
		babinfo->osc[i] = 0xff;
	}
	if (i < BAB_OSC && fast > 0 && fast <= BAB_OSC)
		babinfo->osc[i++] = bab_osc_bits[fast - 1];
	for (; i < BAB_OSC; i++)
		babinfo->osc[i] = 0x00;

	applog(LOG_DEBUG, "@osc(chip=%d) fast=%d 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x", chip, fast, babinfo->osc[0], babinfo->osc[1], babinfo->osc[2], babinfo->osc[3], babinfo->osc[4], babinfo->osc[5], babinfo->osc[6], babinfo->osc[7]);
}

static bool bab_put(struct cgpu_info *babcgpu, struct bab_info *babinfo)
{
	int buf, i, reg, bank = 0;

	babinfo->buffer = -1;

	mutex_lock(&(babinfo->spi_lock));
	if (babinfo->buf_status[0] == BAB_STATE_DONE) {
		babinfo->buffer = 0;
	} else if (babinfo->buf_status[1] == BAB_STATE_DONE) {
		babinfo->buffer = 1;
	} else if (babinfo->buf_status[0] == BAB_STATE_READY) {
		babinfo->buf_status[0] = BAB_STATE_DONE;
		babinfo->buffer = 0;
	} else if (babinfo->buf_status[1] == BAB_STATE_READY) {
		babinfo->buf_status[1] = BAB_STATE_DONE;
		babinfo->buffer = 1;
	}
	mutex_unlock(&(babinfo->spi_lock));

	if (babinfo->buffer == -1)
		return false;

	buf = babinfo->buffer;
	babinfo->buf_used[buf] = 0;
	memset(babinfo->bank_off[buf], 0, sizeof(babinfo->bank_off) / BAB_SPI_BUFFERS);

	BAB_ADD_BREAK();
	for (i = 0; i < babinfo->chips; i++) {
		if (babinfo->chip_bank[i] != bank) {
			babinfo->bank_off[buf][bank] = babinfo->buf_used[buf];
			bank = babinfo->chip_bank[i];
			BAB_ADD_BREAK();
		}
		if (i == babinfo->fixchip &&
		    (BAB_CFGD_SET(babinfo->chip_conf[i]) ||
		     !babinfo->chip_conf[i])) {
			bab_set_osc(babinfo, i);
			bab_add_data(BAB_OSC_ADDR, babinfo->osc, sizeof(babinfo->osc));
			bab_config_reg(BAB_ICLK_REG, BAB_ICLK_BIT(babinfo->chip_conf[i]));
			bab_config_reg(BAB_FAST_REG, BAB_FAST_BIT(babinfo->chip_conf[i]));
			bab_config_reg(BAB_DIV2_REG, BAB_DIV2_BIT(babinfo->chip_conf[i]));
			bab_config_reg(BAB_SLOW_REG, BAB_SLOW_BIT(babinfo->chip_conf[i]));
			bab_config_reg(BAB_OCLK_REG, BAB_OCLK_BIT(babinfo->chip_conf[i]));
			for (reg = BAB_REG_CLR_FROM; reg <= BAB_REG_CLR_TO; reg++)
				bab_config_reg(reg, false);
			if (babinfo->chip_conf[i]) {
				bab_add_data(BAB_COUNT_ADDR, bab_counters, sizeof(bab_counters));
				bab_add_data(BAB_W1A_ADDR, bab_w1, sizeof(bab_w1));
				bab_add_data(BAB_W1B_ADDR, bab_w1, sizeof(bab_w1)/2);
				bab_add_data(BAB_W2_ADDR, bab_w2, sizeof(bab_w2));
				babinfo->chip_conf[i] ^= BAB_CFGD_VAL;
			}
			babinfo->old_fast[i] = babinfo->chip_fast[i];
			babinfo->old_conf[i] = babinfo->chip_conf[i];
		} else {
			if (babinfo->old_fast[i] != babinfo->chip_fast[i]) {
				bab_set_osc(babinfo, i);
				bab_add_data(BAB_OSC_ADDR, babinfo->osc, sizeof(babinfo->osc));
				babinfo->old_fast[i] = babinfo->chip_fast[i];
			}
			if (babinfo->old_conf[i] != babinfo->chip_conf[i]) {
				if (BAB_ICLK_SET(babinfo->old_conf[i]) !=
						 BAB_ICLK_SET(babinfo->chip_conf[i]))
					bab_config_reg(BAB_ICLK_REG,
							BAB_ICLK_BIT(babinfo->chip_conf[i]));
				if (BAB_FAST_SET(babinfo->old_conf[i]) !=
						 BAB_FAST_SET(babinfo->chip_conf[i]))
					bab_config_reg(BAB_FAST_REG,
							BAB_FAST_BIT(babinfo->chip_conf[i]));
				if (BAB_DIV2_SET(babinfo->old_conf[i]) !=
						 BAB_DIV2_SET(babinfo->chip_conf[i]))
					bab_config_reg(BAB_DIV2_REG,
							BAB_DIV2_BIT(babinfo->chip_conf[i]));
				if (BAB_SLOW_SET(babinfo->old_conf[i]) !=
						 BAB_SLOW_SET(babinfo->chip_conf[i]))
					bab_config_reg(BAB_SLOW_REG,
							BAB_SLOW_BIT(babinfo->chip_conf[i]));
				if (BAB_OCLK_SET(babinfo->old_conf[i]) !=
						 BAB_OCLK_SET(babinfo->chip_conf[i]))
					bab_config_reg(BAB_OCLK_REG,
							BAB_OCLK_BIT(babinfo->chip_conf[i]));
				babinfo->old_conf[i] = babinfo->chip_conf[i];
			}
		}
		babinfo->chip_off[buf][i] = babinfo->buf_used[buf] + 3;
		if (babinfo->chip_conf[i])
			bab_add_data(BAB_INP_ADDR, (uint8_t *)(&(babinfo->chip_input[i])),
					sizeof(babinfo->chip_input[i]));

		BAB_ADD_ASYNC();
	}
	babinfo->chip_off[buf][i] = babinfo->buf_used[buf];
	babinfo->bank_off[buf][bank] = babinfo->buf_used[buf];

	mutex_lock(&(babinfo->spi_lock));
	babinfo->buf_status[buf] = BAB_STATE_READY;
	mutex_unlock(&(babinfo->spi_lock));

	babinfo->fixchip = (babinfo->fixchip + 1) % babinfo->chips;
	return true;
}

static bool bab_get(__maybe_unused struct cgpu_info *babcgpu, struct bab_info *babinfo)
{
	int buf, i;

	babinfo->buffer = -1;

	mutex_lock(&(babinfo->spi_lock));
	if (babinfo->buf_status[0] == BAB_STATE_SENT) {
		babinfo->buf_status[0] = BAB_STATE_READING;
		babinfo->buffer = 0;
	} else if (babinfo->buf_status[1] == BAB_STATE_SENT) {
			babinfo->buf_status[1] = BAB_STATE_READING;
			babinfo->buffer = 1;
	}
	mutex_unlock(&(babinfo->spi_lock));

	if (babinfo->buffer == -1)
		return false;

	buf = babinfo->buffer;
	for (i = 0; i < babinfo->chips; i++) {
		if (babinfo->chip_conf[i] & 0x7f) {
			memcpy((void *)&(babinfo->chip_results[i]),
				(void *)(babinfo->buf_read[buf] + babinfo->chip_off[buf][i]),
				sizeof(babinfo->chip_results[0]));
		}
	}

	mutex_lock(&(babinfo->spi_lock));
	babinfo->buf_status[buf] = BAB_STATE_DONE;
	mutex_unlock(&(babinfo->spi_lock));

	return true;
}

void bab_detect_chips(struct cgpu_info *babcgpu, struct bab_info *babinfo, int bank, int first, int last)
{
	int buf, i, reg, j;

	if (sizeof(struct bab_work_send) != sizeof(bab_test_data)) {
		quithere(1, "struct bab_work_send (%d) and bab_test_data (%d)"
			    " must be the same size",
			    (int)sizeof(struct bab_work_send),
			    (int)sizeof(bab_test_data));
	}

	memset(babinfo->bank_off, 0, sizeof(babinfo->bank_off));

	buf = babinfo->buffer = 0;
	babinfo->buf_used[buf] = 0;
	BAB_ADD_BREAK();
	for (i = first; i < last && i < BAB_MAXCHIPS; i++) {
		bab_set_osc(babinfo, i);
		bab_add_data(BAB_OSC_ADDR, babinfo->osc, sizeof(babinfo->osc));
		bab_config_reg(BAB_ICLK_REG, BAB_ICLK_BIT(babinfo->chip_conf[i]));
		bab_config_reg(BAB_FAST_REG, BAB_FAST_BIT(babinfo->chip_conf[i]));
		bab_config_reg(BAB_DIV2_REG, BAB_DIV2_BIT(babinfo->chip_conf[i]));
		bab_config_reg(BAB_SLOW_REG, BAB_SLOW_BIT(babinfo->chip_conf[i]));
		bab_config_reg(BAB_OCLK_REG, BAB_OCLK_BIT(babinfo->chip_conf[i]));
		for (reg = BAB_REG_CLR_FROM; reg <= BAB_REG_CLR_TO; reg++)
			bab_config_reg(reg, false);
		bab_add_data(BAB_COUNT_ADDR, bab_counters, sizeof(bab_counters));
		bab_add_data(BAB_W1A_ADDR, bab_w1, sizeof(bab_w1));
		bab_add_data(BAB_W1B_ADDR, bab_w1, sizeof(bab_w1)/2);
		bab_add_data(BAB_W2_ADDR, bab_w2, sizeof(bab_w2));
		babinfo->chip_off[buf][i] = babinfo->buf_used[buf] + 3;
		bab_add_data(BAB_INP_ADDR, bab_test_data, sizeof(bab_test_data));
		babinfo->chip_off[buf][i+1] = babinfo->buf_used[buf];
		babinfo->bank_off[buf][bank] = babinfo->buf_used[buf];
		babinfo->chips = i + 1;
		bab_txrx(buf, babinfo->buf_used[buf], false);
		babinfo->buf_used[buf] = 0;
		BAB_ADD_BREAK();
		for (j = first; j <= i; j++) {
			babinfo->chip_off[buf][j] = babinfo->buf_used[buf] + 3;
			BAB_ADD_ASYNC();
		}
	}

	buf = babinfo->buffer = 1;
	babinfo->buf_used[buf] = 0;
	BAB_ADD_BREAK();
	for (i = first; i < last && i < BAB_MAXCHIPS; i++) {
		babinfo->chip_off[buf][i] = babinfo->buf_used[buf] + 3;
		bab_add_data(BAB_INP_ADDR, bab_test_data, sizeof(bab_test_data));
		BAB_ADD_ASYNC();
	}
	babinfo->chip_off[buf][i] = babinfo->buf_used[buf];
	babinfo->bank_off[buf][bank] = babinfo->buf_used[buf];
	babinfo->chips = i;
	bab_txrx(buf, babinfo->buf_used[buf], true);
	babinfo->buf_used[buf] = 0;
	babinfo->chips = first;
	for (i = first; i < last && i < BAB_MAXCHIPS; i++) {
		uint32_t tmp[DATA_UINTS-1];
		memcpy(tmp, babinfo->buf_read[buf]+babinfo->chip_off[buf][i], sizeof(tmp));
		for (j = 0; j < BAB_SPI_BUFFERS; j++)
			babinfo->chip_off[j][i] = 0;
		for (j = 0; j < BAB_REPLY_NONCES; j++) {
			if (tmp[j] != 0xffffffff && tmp[j] != 0x00000000) {
				babinfo->chip_bank[i] = bank;
				babinfo->chips = i + 1;
				break;
			}
		}
	}
	for (i = first ; i < babinfo->chips; i++)
		babinfo->chip_bank[i] = bank;
}

static const char *bab_modules[] = {
	"i2c-dev",
	"i2c-bcm2708",
	"spidev",
	"spi-bcm2708",
	NULL
};

static const char *bab_memory = "/dev/mem";

static int bab_memory_addr = 0x20200000;

static struct {
	int request;
	int value;
} bab_ioc[] = {
	{ SPI_IOC_RD_MODE, 0 },
	{ SPI_IOC_WR_MODE, 0 },
	{ SPI_IOC_RD_BITS_PER_WORD, 8 },
	{ SPI_IOC_WR_BITS_PER_WORD, 8 },
	{ SPI_IOC_RD_MAX_SPEED_HZ, 1000000 },
	{ SPI_IOC_WR_MAX_SPEED_HZ, 1000000 },
	{ -1, -1 }
};

static bool bab_init_gpio(struct cgpu_info *babcgpu, struct bab_info *babinfo, int bus, int chip)
{
	int i, err, memfd, data;
	char buf[64];

	for (i = 0; bab_modules[i]; i++) {
		snprintf(buf, sizeof(buf), "modprobe %s", bab_modules[i]);
		err = system(buf);
		if (err) {
			applog(LOG_ERR, "%s failed to modprobe %s (%d) - you need to be root?",
					babcgpu->drv->dname,
					bab_modules[i], err);
			goto bad_out;
		}
	}

	memfd = open(bab_memory, O_RDWR | O_SYNC);
	if (memfd < 0) {
		applog(LOG_ERR, "%s failed open %s (%d)",
				babcgpu->drv->dname,
				bab_memory, errno);
		goto bad_out;
	}

	babinfo->gpio = (volatile unsigned *)mmap(NULL, BAB_SPI_BUFSIZ,
						  PROT_READ | PROT_WRITE,
						  MAP_SHARED, memfd,
						  bab_memory_addr);
	if (babinfo->gpio == MAP_FAILED) {
		close(memfd);
		applog(LOG_ERR, "%s failed mmap gpio (%d)",
				babcgpu->drv->dname,
				errno);
		goto bad_out;
	}

	close(memfd);

	snprintf(buf, sizeof(buf), "/dev/spidev%d.%d", bus, chip);
	babinfo->spifd = open(buf, O_RDWR);
	if (babinfo->spifd < 0) {
		applog(LOG_ERR, "%s failed to open spidev (%d)",
				babcgpu->drv->dname,
				errno);
		goto map_out;
	}

	babcgpu->device_path = strdup(buf);

	for (i = 0; bab_ioc[i].value != -1; i++) {
		data = bab_ioc[i].value;
		err = ioctl(babinfo->spifd, bab_ioc[i].request, (void *)&data);
		if (err < 0) {
			applog(LOG_ERR, "%s failed ioctl (%d) (%d)",
					babcgpu->drv->dname,
					i, errno);
			goto close_out;
		}
	}

	for (i = 0; i < BAB_MAXCHIPS; i++)
		babinfo->chip_spis[i] = (int)((1000000.0 / (100.0 + 31.0 * (i + 1))) * 1000);

	return true;

close_out:
	close(babinfo->spifd);
	babinfo->spifd = 0;
	free(babcgpu->device_path);
	babcgpu->device_path = NULL;
map_out:
	munmap((void *)(babinfo->gpio), BAB_SPI_BUFSIZ);
	babinfo->gpio = NULL;
bad_out:
	return false;
}

static void bab_init_chips(struct cgpu_info *babcgpu, struct bab_info *babinfo)
{
	bab_detect_chips(babcgpu, babinfo, 0, 0, BAB_MAXCHIPS);
	memcpy(babinfo->old_conf, babinfo->chip_conf, sizeof(babinfo->old_conf));
	memcpy(babinfo->old_fast, babinfo->chip_fast, sizeof(babinfo->old_fast));
}

static void bab_detect(bool hotplug)
{
	struct cgpu_info *babcgpu = NULL;
	struct bab_info *babinfo = NULL;
	int i;

	if (hotplug)
		return;

	babcgpu = calloc(1, sizeof(*babcgpu));
	if (unlikely(!babcgpu))
		quithere(1, "Failed to calloc babcgpu");

	babcgpu->drv = &bab_drv;
	babcgpu->deven = DEV_ENABLED;
	babcgpu->threads = 1;

	babinfo = calloc(1, sizeof(*babinfo));
	if (unlikely(!babinfo))
		quithere(1, "Failed to calloc babinfo");
	babcgpu->device_data = (void *)babinfo;

	for (i = 0; i < BAB_MAXCHIPS; i++) {
		babinfo->chip_conf[i] = BAB_DEFCONF;
		babinfo->chip_fast[i] = BAB_DEFSPEED;
	}

	mutex_init(&babinfo->spi_lock);

	if (!bab_init_gpio(babcgpu, babinfo, BAB_SPI_BUS, BAB_SPI_CHIP))
		goto unalloc;

	applog(LOG_WARNING, "%s V1 testing for %d chips ...", babcgpu->drv->dname, BAB_MAXCHIPS);

	bab_init_chips(babcgpu, babinfo);

	applog(LOG_WARNING, "%s found %d chips", babcgpu->drv->dname, babinfo->chips);

	if (babinfo->chips == 0)
		goto cleanup;

	if (!add_cgpu(babcgpu))
		goto cleanup;

	mutex_init(&babinfo->res_lock);
	mutex_init(&babinfo->did_lock);
	cglock_init(&babinfo->blist_lock);

	babinfo->initialised = true;

	return;

cleanup:
	close(babinfo->spifd);
	munmap((void *)(babinfo->gpio), BAB_SPI_BUFSIZ);
unalloc:
	mutex_destroy(&babinfo->spi_lock);
	free(babinfo);
	free(babcgpu);
}

static void bab_identify(__maybe_unused struct cgpu_info *babcgpu)
{
}

#define BAB_LONG_WAIT_uS 1200000
#define BAB_WAIT_MSG_EVERY 10
#define BAB_LONG_WAIT_SLEEP_uS 100000
#define BAB_STD_WAIT_uS 3000

// thread to do spi txrx
static void *bab_spi(void *userdata)
{
	struct cgpu_info *babcgpu = (struct cgpu_info *)userdata;
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	struct timeval start, stop;
	double wait;
	int i, buf, msgs;

	applog(LOG_DEBUG, "%s%i: SPIing...",
			  babcgpu->drv->name, babcgpu->device_id);

	// Wait until we're ready
	while (babcgpu->shutdown == false) {
		if (babinfo->initialised) {
			break;
		}
		cgsleep_ms(3);
	}

	msgs = 0;
	cgtime(&start);
	while (babcgpu->shutdown == false) {
		buf = -1;
		mutex_lock(&(babinfo->spi_lock));
		for (i = 0; i < BAB_SPI_BUFFERS; i++) {
			if (babinfo->buf_status[i] == BAB_STATE_READY) {
				babinfo->buf_status[i] = BAB_STATE_SENDING;
				buf = i;
				cgtime(&start);
				break;
			}
		}
		mutex_unlock(&(babinfo->spi_lock));

		if (buf == -1) {
			cgtime(&stop);
			wait = us_tdiff(&stop, &start);
			if (wait > BAB_LONG_WAIT_uS) {
				if ((msgs++ % BAB_WAIT_MSG_EVERY) == 0) {
					applog(LOG_WARNING, "%s%i: SPI waiting %.0fus ...",
								babcgpu->drv->name,
								babcgpu->device_id,
								(float)wait);
				}
			}
			cgsleep_us(BAB_LONG_WAIT_SLEEP_uS);
			continue;
		}

		bab_txrx(buf, babinfo->buf_used[buf], false);
		cgtime(&stop);
		wait = us_tdiff(&stop, &start);
		if (wait < BAB_STD_WAIT_uS)
			cgsleep_us((uint64_t)(BAB_STD_WAIT_uS - wait));
		else if (wait > BAB_LONG_WAIT_uS) {
			applog(LOG_DEBUG, "%s%i: SPI waited %.0fus",
					  babcgpu->drv->name, babcgpu->device_id,
					  (float)wait);
		}

		mutex_lock(&(babinfo->spi_lock));
		babinfo->buf_status[i] = BAB_STATE_SENT;
		mutex_unlock(&(babinfo->spi_lock));
		msgs = 0;
	}

	return NULL;
}

static void bab_flush_work(struct cgpu_info *babcgpu)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);

	applog(LOG_DEBUG, "%s%i: flushing work",
			  babcgpu->drv->name, babcgpu->device_id);

	mutex_lock(&(babinfo->did_lock));
	memset(&(babinfo->last_did), 0, sizeof(babinfo->last_did));
	mutex_unlock(&(babinfo->did_lock));
}

static void ms3steps(uint32_t *p)
{
	uint32_t a, b, c, d, e, f, g, h, new_e, new_a;
	int i;

	a = p[0];
	b = p[1];
	c = p[2];
	d = p[3];
	e = p[4];
	f = p[5];
	g = p[6];
	h = p[7];
	for (i = 0; i < 3; i++) {
		new_e = p[i+16] + sha256_k[i] + h + CH(e,f,g) + SHA256_F2(e) + d;
		new_a = p[i+16] + sha256_k[i] + h + CH(e,f,g) + SHA256_F2(e) +
			SHA256_F1(a) + MAJ(a,b,c);
		d = c;
		c = b;
		b = a;
		a = new_a;
		h = g;
		g = f;
		f = e;
		e = new_e;
	}
	p[15] = a;
	p[14] = b;
	p[13] = c;
	p[12] = d;
	p[11] = e;
	p[10] = f;
	p[9] = g;
	p[8] = h;
}

#define DATA_MERKLE7 16
#define DATA_NTIME 17
#define DATA_BITS 18
#define DATA_NONCE 19

#define WORK_MERKLE7 (16*4)
#define WORK_NTIME (17*4)
#define WORK_BITS (18*4)
#define WORK_NONCE (19*4)

static uint32_t decnonce(uint32_t in)
{
	uint32_t out;

	/* First part load */
	out = (in & 0xFF) << 24;
	in >>= 8;

	/* Byte reversal */
	in = (((in & 0xaaaaaaaa) >> 1) | ((in & 0x55555555) << 1));
	in = (((in & 0xcccccccc) >> 2) | ((in & 0x33333333) << 2));
	in = (((in & 0xf0f0f0f0) >> 4) | ((in & 0x0f0f0f0f) << 4));

	out |= (in >> 2) & 0x3FFFFF;

	/* Extraction */
	if (in & 1)
		out |= (1 << 23);
	if (in & 2)
		out |= (1 << 22);

	out -= 0x800004;
	return out;
}

/*
 * Find the matching work item by checking the nonce against each work
 * item for the chip
 * Discard any work items older than a match
 */
static bool oknonce(struct thr_info *thr, struct cgpu_info *babcgpu, int chip, uint32_t nonce)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	BLIST *bitem;
	unsigned int links, tests;
	int i;

	babinfo->chip_nonces[chip]++;

	nonce = decnonce(nonce);

	/*
	 * We can grab the head of the chip work queue and then
	 * release the lock and follow it to the end
	 * since the other thread will only add items above the
	 * head - it wont touch the list->next pointers from the
	 * head to the end - only the head->prev pointer may get
	 * changed
	 */
	cg_rlock(&babinfo->blist_lock);
	bitem = babinfo->chip_list[chip];
	cg_runlock(&babinfo->blist_lock);

	if (!bitem) {
		applog(LOG_ERR, "%s%i: chip %d has no work!",
				babcgpu->drv->name, babcgpu->device_id, chip);
		babinfo->untested_nonces++;
		return false;
	}

	babinfo->tested_nonces++;

	tests = 0;
	links = 0;
	while (bitem) {
		if (!bitem->work) {
			applog(LOG_ERR, "%s%i: chip %d bitem links %d has no work!",
					babcgpu->drv->name,
					babcgpu->device_id,
					chip, links);
		} else {
			for (i = 0; i < BAB_NONCE_OFFSETS; i++) {
				tests++;
				if (test_nonce(bitem->work, nonce + bab_nonce_offsets[i])) {
					submit_tested_work(thr, bitem->work);
					babinfo->nonce_offset_count[i]++;
					babinfo->chip_good[chip]++;
					bitem->nonces++;
					babinfo->new_nonces++;
					babinfo->ok_nonces++;
					free_blist(babcgpu, bitem->next, chip);
					babinfo->total_tests += tests;
					if (babinfo->max_tests_per_nonce < tests)
						babinfo->max_tests_per_nonce = tests;
					babinfo->total_links += links;
					if (babinfo->max_links < links)
						babinfo->max_links = links;
					return true;
				}
			}
		}
		bitem = bitem->next;
		links++;
	}

	if (babinfo->not_first_reply[chip]) {
		babinfo->chip_bad[chip]++;
		inc_hw_errors(thr);
	} else
		babinfo->initial_ignored++;

	return false;
}

// Results checking thread
static void *bab_res(void *userdata)
{
	struct cgpu_info *babcgpu = (struct cgpu_info *)userdata;
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	struct thr_info *thr = babcgpu->thr[0];
	bool first_second;
	uint32_t nonce;
	int chip;

	applog(LOG_DEBUG, "%s%i: Results...",
			  babcgpu->drv->name, babcgpu->device_id);

	// Wait until we're ready
	while (babcgpu->shutdown == false) {
		if (babinfo->initialised) {
			break;
		}
		cgsleep_ms(3);
	}

	while (babcgpu->shutdown == false) {
		if (!oldest_nonce(babcgpu, &chip, &nonce, &first_second)) {
			cgsleep_ms(3);
			continue;
		}

		if (first_second)
			babinfo->not_first_reply[chip] = true;

		oknonce(thr, babcgpu, chip, nonce);
	}

	return NULL;
}

static bool bab_do_work(struct cgpu_info *babcgpu)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	int busy, newbusy, match, work_items = 0;
	int spi, mis, miso;
	int i, j;
	BLIST *bitem;
	bool res, got_a_nonce;

	for (i = 0; i < babinfo->chips; i++) {
		bitem = next_work(babcgpu, i);
		if (!bitem) {
			applog(LOG_ERR, "%s%i: short work list (%i) expected %d - discarded",
					babcgpu->drv->name, babcgpu->device_id,
					i, babinfo->chips);
			for (j = 0; j < i; i++)
				discard_last(babcgpu, j);

			return false;
		}
		memcpy((void *)&(babinfo->chip_input[i].midstate[0]),
			bitem->work->midstate, sizeof(bitem->work->midstate));
		memcpy((void *)&(babinfo->chip_input[i].merkle7),
			(void *)&(bitem->work->data[WORK_MERKLE7]), 12);

		ms3steps((void *)&(babinfo->chip_input[i]));
		work_items++;
	}

	// Send
	res = bab_put(babcgpu, babinfo);
	if (!res) {
		applog(LOG_DEBUG, "%s%i: couldn't put work ...",
				  babcgpu->drv->name, babcgpu->device_id);
	}

	// Receive
	res = bab_get(babcgpu, babinfo);
	if (!res) {
		applog(LOG_DEBUG, "%s%i: didn't get work reply ...",
				  babcgpu->drv->name, babcgpu->device_id);
		return false;
	}

	applog(LOG_DEBUG, "%s%i: Did get work reply ...",
			  babcgpu->drv->name, babcgpu->device_id);

	spi = mis = miso = 0;

	for (i = 0; i < babinfo->chips; i++) {
		match = 0;
		newbusy = busy = babinfo->chip_busy[i];

		if (!babinfo->chip_conf[i])
			continue;

		for (j = 1; j < BAB_REPLY_NONCES; j++) {
			if (babinfo->chip_results[i].nonce[(busy+j) % BAB_REPLY_NONCES] !=
			    babinfo->chip_prev[i].nonce[(busy+j) % BAB_REPLY_NONCES])
				newbusy = (busy+j) % BAB_REPLY_NONCES;
			else
				match++;
		}

		if (!match) {
			if (!miso) {
				mis++;
// ignore for now ...				babinfo->chip_miso[i]++;
			}
			miso = 1;
			continue;
		}

		miso = 0;
		if (babinfo->chip_results[i].jobsel != 0xffffffff &&
		    babinfo->chip_results[i].jobsel != 0x00000000) {
			spi++;
			babinfo->chip_spie[i]++;
			applog(LOG_DEBUG, "%s%i: SPI ERROR on chip %d (0x%08x)",
					  babcgpu->drv->name, babcgpu->device_id,
					  i, babinfo->chip_results[i].jobsel);
		}

// Not used yet
//		if (babinfo->chip_results[i].jobsel != babinfo->chip_prev[i].jobsel) {

		got_a_nonce = false;
		for (; newbusy != busy; busy = (busy + 1) % BAB_REPLY_NONCES) {
			if (babinfo->chip_results[i].nonce[busy] == 0xffffffff ||
			    babinfo->chip_results[i].nonce[busy] == 0x00000000) {
				babinfo->chip_results[i].nonce[busy] = babinfo->chip_prev[i].nonce[busy];
				spi = 1;
				continue;
			}

			store_nonce(babcgpu, i,
				    babinfo->chip_results[i].nonce[busy],
				    babinfo->nonce_before[i]);

			got_a_nonce = true;
		}

		/*
		 * We only care about this after the first reply we find a nonce
		 * After that, the value has no more effect
		 */
		if (got_a_nonce)
			babinfo->nonce_before[i] = true;

		mis += miso;
		babinfo->chip_miso[i] += miso;
		babinfo->chip_busy[i] = busy;
	}

	memcpy((void *)(&(babinfo->chip_prev[0])),
		(void *)(&(babinfo->chip_results[0])),
		sizeof(babinfo->chip_prev));

	applog(LOG_DEBUG, "Work: items:%d spi:%d miso:%d",
			  work_items, spi, mis);

	return true;
}

static bool bab_thread_prepare(struct thr_info *thr)
{
	struct cgpu_info *babcgpu = thr->cgpu;
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);

	if (thr_info_create(&(babinfo->spi_thr), NULL, bab_spi, (void *)babcgpu)) {
		applog(LOG_ERR, "%s%i: SPI thread create failed",
				babcgpu->drv->name, babcgpu->device_id);
		return false;
	}
	pthread_detach(babinfo->spi_thr.pth);

	/*
	 * We require a seperate results checking thread since there is a lot
	 * of work done checking the results multiple times - thus we don't
	 * want that delay affecting sending/receiving work to/from the device
	 */
	if (thr_info_create(&(babinfo->res_thr), NULL, bab_res, (void *)babcgpu)) {
		applog(LOG_ERR, "%s%i: Results thread create failed",
				babcgpu->drv->name, babcgpu->device_id);
		return false;
	}
	pthread_detach(babinfo->res_thr.pth);

	return true;
}

static void bab_shutdown(struct thr_info *thr)
{
	struct cgpu_info *babcgpu = thr->cgpu;
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	int i;

	applog(LOG_DEBUG, "%s%i: shutting down",
			  babcgpu->drv->name, babcgpu->device_id);

	for (i = 0; i < babinfo->chips; i++)
// TODO:	bab_shutdown(babcgpu, babinfo, i);
		;

	babcgpu->shutdown = true;
}

static bool bab_queue_full(struct cgpu_info *babcgpu)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	struct work *work;
	bool ret;

	if (babinfo->work_count >= babinfo->chips)
		ret = true;
	else {
		work = get_queued(babcgpu);
		if (work)
			store_work(babcgpu, work);
		else
			// Avoid a hard loop when we can't get work fast enough
			cgsleep_ms(10);

		ret = false;
	}

	return ret;
}

/*
 * 1.0s per nonce = 4.2GH/s
 * So anything around 4GH/s or less per chip should be fine
 */
#define BAB_STD_WORK_uS 1000000

#define BAB_STD_DELAY_uS 30000

/*
 * TODO: allow this to run through more than once - the second+
 * time not sending any new work unless a flush occurs since:
 * at the moment we have BAB_STD_WORK_uS latency added to earliest replies
 */
static int64_t bab_scanwork(__maybe_unused struct thr_info *thr)
{
	struct cgpu_info *babcgpu = thr->cgpu;
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	int64_t hashcount = 0;
	struct timeval now;
	double delay;

	bab_do_work(babcgpu);

	// Sleep now so we get the work "bab_queue_full()" just before we use it
	while (80085) {
		cgtime(&now);
		mutex_lock(&(babinfo->did_lock));
		delay = us_tdiff(&now, &(babinfo->last_did));
		mutex_unlock(&(babinfo->did_lock));
		if (delay < (BAB_STD_WORK_uS - BAB_STD_DELAY_uS))
			cgsleep_us(BAB_STD_DELAY_uS);
		else
			break;
	}

	if (babinfo->new_nonces) {
		hashcount += 0xffffffffull * babinfo->new_nonces;
		babinfo->new_nonces = 0;
	}

	return hashcount;
}

#define CHIPS_PER_STAT 16

static struct api_data *bab_api_stats(struct cgpu_info *babcgpu)
{
	struct bab_info *babinfo = (struct bab_info *)(babcgpu->device_data);
	struct api_data *root = NULL;
	char data[2048];
	char buf[32];
	int i, to, j;

	if (babinfo->initialised == false)
		return NULL;

	root = api_add_int(root, "Chips", &(babinfo->chips), true);

	for (i = 0; i < babinfo->chips; i += CHIPS_PER_STAT) {
		to = i + CHIPS_PER_STAT - 1;
		if (to >= babinfo->chips)
			to = babinfo->chips - 1;

		data[0] = '\0';
		for (j = i; j <= to; j++) {
			snprintf(buf, sizeof(buf),
					"%s%"PRIu64,
					j == i ? "" : " ",
					babinfo->chip_nonces[j]);
			strcat(data, buf);
		}
		snprintf(buf, sizeof(buf), "Nonces %d - %d", i, to);
		root = api_add_string(root, buf, data, true);

		data[0] = '\0';
		for (j = i; j <= to; j++) {
			snprintf(buf, sizeof(buf),
					"%s%"PRIu64,
					j == i ? "" : " ",
					babinfo->chip_good[j]);
			strcat(data, buf);
		}
		snprintf(buf, sizeof(buf), "Good %d - %d", i, to);
		root = api_add_string(root, buf, data, true);

		data[0] = '\0';
		for (j = i; j <= to; j++) {
			snprintf(buf, sizeof(buf),
					"%s%"PRIu64,
					j == i ? "" : " ",
					babinfo->chip_bad[j]);
			strcat(data, buf);
		}
		snprintf(buf, sizeof(buf), "Bad %d - %d", i, to);
		root = api_add_string(root, buf, data, true);

		data[0] = '\0';
		for (j = i; j <= to; j++) {
			snprintf(buf, sizeof(buf),
					"%s0x%02x",
					j == i ? "" : " ",
					(int)(babinfo->chip_conf[j]));
			strcat(data, buf);
		}
		snprintf(buf, sizeof(buf), "Conf %d - %d", i, to);
		root = api_add_string(root, buf, data, true);

		data[0] = '\0';
		for (j = i; j <= to; j++) {
			snprintf(buf, sizeof(buf),
					"%s0x%02x",
					j == i ? "" : " ",
					(int)(babinfo->chip_fast[j]));
			strcat(data, buf);
		}
		snprintf(buf, sizeof(buf), "Fast %d - %d", i, to);
		root = api_add_string(root, buf, data, true);
	}

	for (i = 0; i < BAB_NONCE_OFFSETS; i++) {
		snprintf(buf, sizeof(buf), "Nonce Offset 0x%08x", bab_nonce_offsets[i]);
		root = api_add_uint64(root, buf, &(babinfo->nonce_offset_count[i]), true);
	}

	root = api_add_uint64(root, "Tested", &(babinfo->tested_nonces), true);
	root = api_add_uint64(root, "Total Tests", &(babinfo->total_tests), true);
	root = api_add_uint64(root, "Max Tests", &(babinfo->max_tests_per_nonce), true);
	float avg = babinfo->tested_nonces ? (float)(babinfo->total_tests) /
					     (float)(babinfo->tested_nonces) : 0;
// TODO: add a API_AVG which is 3 places - double/float?
	root = api_add_volts(root, "Avg Tests", &avg, true);
	root = api_add_uint64(root, "Untested", &(babinfo->untested_nonces), true);

	root = api_add_uint64(root, "Work Links", &(babinfo->total_links), true);
	root = api_add_uint64(root, "Max Links", &(babinfo->max_links), true);
	avg = babinfo->tested_nonces ? (float)(babinfo->total_links) /
					(float)(babinfo->tested_nonces) : 0;
	root = api_add_volts(root, "Avg Links", &avg, true);

	root = api_add_uint32(root, "Initial Ignored", &(babinfo->initial_ignored), true);

	root = api_add_int(root, "BList Count", &(babinfo->blist_count), true);
	root = api_add_int(root, "BFree Count", &(babinfo->bfree_count), true);
	root = api_add_int(root, "Work Count", &(babinfo->work_count), true);
	root = api_add_int(root, "Chip Count", &(babinfo->chip_count), true);

	root = api_add_int(root, "RList Count", &(babinfo->rlist_count), true);
	root = api_add_int(root, "RFree Count", &(babinfo->rfree_count), true);
	root = api_add_int(root, "Result Count", &(babinfo->res_count), true);

	return root;
}
#endif

struct device_drv bab_drv = {
	.drv_id = DRIVER_bab,
	.dname = "BlackArrowBitFuryGPIO",
	.name = "BaB",
	.drv_detect = bab_detect,
#ifdef LINUX
	.get_api_stats = bab_api_stats,
//TODO:	.get_statline_before = get_bab_statline_before,
	.identify_device = bab_identify,
	.thread_prepare = bab_thread_prepare,
	.hash_work = hash_queued_work,
	.scanwork = bab_scanwork,
	.queue_full = bab_queue_full,
	.flush_work = bab_flush_work,
	.thread_shutdown = bab_shutdown
#endif
};