BlackArrowBitfury early GPIO V1 driver

driver-bab.c

@@ -1,14 +1,1872 @@
+/*
+ * Copyright 2013 Andrew Smith
+ * Copyright 2013 bitfury
+ *
+ * Details for BitFury GPIO development of this driver are from
+ * the chainminer code: https://github.com/bfsb/chainminer
+ * (coz there seems to be no good documentation of it anywhere ...)
+ * Thanks to the developer of chainminer for providing the source
+ * to base the first version of the gpio/spi code in this BitFury chip
+ * driver :)
+ *
+ * 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"
+
+/*
+ * This code has been tested on RPi running Raspbian
+ * with a 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++)
+//		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
+	.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
 };