new_gekko/bf16-bitfury16.c

#include <arpa/inet.h>

#include "miner.h"

#include "bf16-bitfury16.h"
#include "bf16-communication.h"
#include "bf16-ctrldevice.h"

#include "math.h"
#include "sha2.h"
#include "driver-bitfury16.h"

//#define FLIP_BITS

bf_cmd_description_t cmd_description[CHIP_CMD_NUM] = {
	{
		.cmd_code        = CHIP_CMD_TASK_STATUS,
		.cmd_description = "CHIP_CMD_TASK_STATUS"
	},
	{
		.cmd_code        = CHIP_CMD_TASK_WRITE,
		.cmd_description = "CHIP_CMD_TASK_WRITE"
	},
	{
		.cmd_code        = CHIP_CMD_TASK_SWITCH,
		.cmd_description = "CHIP_CMD_TASK_SWITCH"
	},
	{
		.cmd_code        = CHIP_CMD_READ_NONCE,
		.cmd_description = "CHIP_CMD_READ_NONCE"
	},
	{
		.cmd_code        = CHIP_CMD_SET_CLOCK,
		.cmd_description = "CHIP_CMD_SET_CLOCK"
	},
	{
		.cmd_code        = CHIP_CMD_TOGGLE,
		.cmd_description = "CHIP_CMD_TOGGLE"
	},
	{
		.cmd_code        = CHIP_CMD_SET_MASK,
		.cmd_description = "CHIP_CMD_SET_MASK"
	},
	{
		.cmd_code        = CHIP_CMD_CREATE_CHANNEL,
		.cmd_description = "CHIP_CMD_CREATE_CHANNEL"
	}
};

char* get_cmd_description(bf_cmd_code_t cmd_code)
{
	uint8_t i;

	for (i = 0; i < CHIP_CMD_NUM; i++)
		if (cmd_description[i].cmd_code == cmd_code)
			return cmd_description[i].cmd_description;

	return NULL;
}

static void shift_bits(uint8_t* data, uint8_t size, uint8_t nbits)
{
	uint8_t i;
	uint8_t bytes = nbits / 8;
	uint8_t bits  = nbits % 8;

	for (i = 0; i < size; i++) {
		data[i] = (data[i + bytes] << bits);
		uint8_t minor = (data[i + bytes + 1] >> (8 - bits));
		data[i] |= minor;
	}
}

static uint8_t extra_bytes(uint8_t depth)
{
	return (depth * 3) / 8 + 1;
}

static uint8_t analyze_rx_data(bf_command_t* command, bf_cmd_status_t* cmd_status, uint32_t* nonces)
{
	uint8_t i;
	uint8_t res = 0;

	if (command->cmd_code & CHIP_CMD_READ_NONCE) {
		shift_bits(command->rx, 49 + 2 + extra_bytes(command->depth), command->depth * 3);

		command->status	   = command->rx[0];
		cmd_status->status = command->rx[0];
		command->checksum             = command->rx[1];
		cmd_status->checksum_expected = command->checksum;

		if (nonces == NULL)
			return 1;

		uint32_t nonce = 0x00000000;

		/* fill nonces buffer */
		for (i = 0; i <= 48; i++) {
			if ((i % 4 == 0) && (i != 0)) {
				if ((nonce & 0x0fffffff) != 0x0fffffff)
					nonce ^= 0xaaaaaaaa;
				nonces[i/4 - 1] = nonce;

				if (i == 48)
					break;

				nonce = 0x00000000;
			}

			nonce |= (command->rx[i + 2] << 8*(4 - (i%4) - 1));
		}

#if 0
		char data[128];
		memset(data, 0, sizeof(data));
		for (i = 0; i < 49 + 2 + extra_bytes(command->depth); i++)
			sprintf(data, "%s%02x", data, command->rx[i]);
		applog(LOG_DEBUG, "BF16: RX <- [%s]", data);
#endif

		for (i = 0; i < 48; i ++)
			command->nonce_checksum += command->rx[i + 2];
		command->nonce_checksum += command->rx[1];

		cmd_status->nonce_checksum_expected = command->nonce_checksum;

		if (command->checksum != command->rx[1]) {
			command->checksum_error       = true;
			cmd_status->checksum_error    = true;
			cmd_status->checksum_received = command->rx[50];
			res = 1;
#if 0
			applog(LOG_ERR, "Checksum mismatch: received [%02x] expected [%02x]", command->rx[1], 0x04);
#endif
		} else {
			command->checksum_error    = false;
			cmd_status->checksum_error = false;
		}

		if ((command->nonce_checksum != command->rx[50]) &&
			(command->nonce_checksum != command->rx[50] + 1)) {
			command->nonce_checksum_error       = true;
			cmd_status->nonce_checksum_error    = true;
			cmd_status->nonce_checksum_received = command->rx[50];

			res += 2;
#if 0
			applog(LOG_ERR, "Nonce checksum mismatch: received [%02x] expected [%02x]", command->rx[50], checksum);
#endif
		} else {
			command->nonce_checksum_error    = false;
			cmd_status->nonce_checksum_error = false;
		}
	} else {
		shift_bits(command->rx, 2 + extra_bytes(command->depth), command->depth * 3);

		if (opt_bf16_test_chip != NULL) {
			char data[16];
			memset(data, 0, sizeof(data));
			for (i = 0; i < 2 + extra_bytes(command->depth); i++)
				sprintf(data, "%s%02x", data, command->rx[i]);
			applog(LOG_NOTICE, "BF16: RX <- [%s]", data);
		}

		command->status	     = command->rx[0];
		cmd_status->status   = command->rx[0];
		uint8_t cmd_checksum = command->rx[1];
		cmd_status->checksum_expected = command->checksum;

#if 0
		applog(LOG_DEBUG, "Command checksum: [%02x]", cmd_checksum);
		applog(LOG_DEBUG, "Command status:   [%02x]", command->status);
#endif

		if ((command->checksum != cmd_checksum) &&
		    (command->checksum != cmd_checksum + 1)) {
			command->checksum_error       = true;
			cmd_status->checksum_error    = true;
			cmd_status->checksum_received = cmd_checksum;
			res = 1;

			if (opt_bf16_test_chip != NULL) {
				applog(LOG_ERR, "BF16: checksum mismatch: received [%02x] expected [%02x]",
						cmd_checksum, command->checksum);
			}
		} else {
			command->checksum_error    = false;
			cmd_status->checksum_error = false;
		}
	}

	return res;
}

/* SPI BTC250 primitives */
uint8_t create_channel(spi_channel_id_t spi_channel, uint8_t* channel_path, uint8_t channel_length)
{
	int res = 0;

	uint8_t* channel_path_buff = cgcalloc(channel_length, sizeof(uint8_t));
	cg_memcpy(channel_path_buff, channel_path, channel_length);

	res = device_spi_transfer(spi_channel, channel_path_buff, channel_length);

	free(channel_path_buff);

	return res;
}

uint8_t destroy_channel(spi_channel_id_t spi_channel, uint8_t depth)
{
	bf_command_t chip_command;
	bf_chip_address_t chip_address = { 0x00, 0x00, 0x0f };

	/* send command to 0x0f address */
	spi_command_init(&chip_command, depth, chip_address, CHIP_CMD_TASK_SWITCH, 0, NULL);
	return spi_command_exec(spi_channel, &chip_command, NULL);
}

/* SPI BTC16 primitives  */
void spi_emit_reset(spi_channel_id_t spi_channel)
{
	device_ctrl_transfer(spi_channel, 1, F_RST);

	uint8_t data[2] = { 0x00, 0x00 };
	device_spi_transfer(spi_channel, data, sizeof(data));

	device_ctrl_transfer(spi_channel, 0, F_RST);
}

uint8_t send_toggle(spi_channel_id_t spi_channel, uint8_t depth, bf_chip_address_t chip_address)
{
	bf_command_t chip_command;
	uint8_t toggle[4] = { 0xa5, 0x00, 0x00, 0x02 };

	spi_command_init(&chip_command, depth, chip_address, CHIP_CMD_TOGGLE, 3, toggle);
	return spi_command_exec(spi_channel, &chip_command, NULL);
}

uint8_t set_clock(spi_channel_id_t spi_channel, uint8_t depth,
		bf_chip_address_t chip_address, uint8_t clock)
{
	bf_command_t chip_command;
	uint8_t clock_buf[4];

	memset(clock_buf, 0, 4);
	gen_clock_data(clock, 1, clock_buf);
	spi_command_init(&chip_command, depth, chip_address, CHIP_CMD_SET_CLOCK, 3, clock_buf);
	return spi_command_exec(spi_channel, &chip_command, NULL);
}

/* cmd buffer primitives */
int8_t cmd_buffer_init(bf_cmd_buffer_t* cmd_buffer)
{
	if (cmd_buffer == NULL)
		return -1;

	cmd_buffer->cmd_list = cgmalloc(sizeof(bf_list_t));
	cmd_buffer->cmd_list->head  = NULL;
	cmd_buffer->cmd_list->tail  = NULL;
	cmd_buffer->cmd_list->count = 0;

	cmd_buffer->tx_buffer = cgcalloc(CMD_BUFFER_LEN, sizeof(uint8_t));
	cmd_buffer->rx_buffer = cgcalloc(CMD_BUFFER_LEN, sizeof(uint8_t));

	memset(cmd_buffer->tx_buffer, 0, CMD_BUFFER_LEN);
	memset(cmd_buffer->rx_buffer, 0, CMD_BUFFER_LEN);

	cmd_buffer->free_bytes = CMD_BUFFER_LEN;
	cmd_buffer->tx_offset  = 0;
	cmd_buffer->rx_offset  = 0;
	cmd_buffer->status     = EMPTY;

	return 0;
}

int8_t cmd_buffer_deinit(bf_cmd_buffer_t* cmd_buffer)
{
	if (cmd_buffer == NULL)
		return -1;

	/* free cmd buffer */
	while (cmd_buffer->cmd_list->head != NULL) {
		bf_data_t* cdata = cmd_buffer->cmd_list->head;
		LIST_POP_HEAD(cmd_buffer->cmd_list);
		free(cdata->data);
		free(cdata);
	}

	free(cmd_buffer->cmd_list);

	/* free RX/TX buffer */
	free(cmd_buffer->tx_buffer);
	free(cmd_buffer->rx_buffer);

	cmd_buffer->free_bytes = CMD_BUFFER_LEN;
	cmd_buffer->tx_offset  = 0;
	cmd_buffer->rx_offset  = 0;
	cmd_buffer->status     = EMPTY;

	return 0;
}

int8_t cmd_buffer_clear(bf_cmd_buffer_t* cmd_buffer)
{
	if (cmd_buffer == NULL)
		return -1;

	/* release cmd buffer data memory */
	while (cmd_buffer->cmd_list->head != NULL) {
		bf_data_t* cdata = cmd_buffer->cmd_list->head;
		LIST_POP_HEAD(cmd_buffer->cmd_list);
		free(cdata->data);
		free(cdata);
	}

	cmd_buffer->cmd_list->count = 0;

	/* clear RX/TX buffer */
	memset(cmd_buffer->tx_buffer, 0, CMD_BUFFER_LEN);
	memset(cmd_buffer->rx_buffer, 0, CMD_BUFFER_LEN);

	cmd_buffer->free_bytes = CMD_BUFFER_LEN;
	cmd_buffer->tx_offset  = 0;
	cmd_buffer->rx_offset  = 0;
	cmd_buffer->status     = EMPTY;

	return 0;
}

int8_t cmd_buffer_push(bf_cmd_buffer_t* cmd_buffer, const uint8_t depth,
		const bf_chip_address_t chip_address, const bf_chip_address_t src_address,
		const bf_works_t work, const uint32_t id,
		const bf_cmd_code_t cmd_code, const uint8_t data_length, const uint8_t* tx)
{
	uint8_t res = 0;

	if (cmd_buffer == NULL)
		return -1;

	if (cmd_buffer->status == EXECUTED)
		return -2;

	bf_command_t command;
	memset(&command, 0, sizeof(bf_command_t));

	uint8_t buff[192];
	memset(buff, 0, sizeof(buff));

	if (cmd_code != CHIP_CMD_CREATE_CHANNEL) {
		res = spi_command_init(&command, depth, chip_address, cmd_code, data_length, tx);
		if (res != 0)
			return res;
	}

	/* init structure */
	bf_data_t* cdata = cgmalloc(sizeof(bf_data_t));
	cdata->data = cgmalloc(sizeof(bf_cmd_t));
	cdata->next = NULL;
	cdata->prev = NULL;

	cg_memcpy(&CMD(cdata)->chip_address, &chip_address, sizeof(bf_chip_address_t));
	cg_memcpy(&CMD(cdata)->src_address,  &src_address,  sizeof(bf_chip_address_t));
	cg_memcpy(&CMD(cdata)->work,         &work,         sizeof(bf_works_t));
	CMD(cdata)->id       = id;
	CMD(cdata)->depth    = command.depth;
	CMD(cdata)->checksum = command.checksum;
	CMD(cdata)->cmd_code = cmd_code;

	if (CMD(cdata)->cmd_code & CHIP_CMD_READ_NONCE)
		CMD(cdata)->data_length = command.data_length + 49 + 2 + extra_bytes(command.depth);
	else if (CMD(cdata)->cmd_code == CHIP_CMD_CREATE_CHANNEL)
		CMD(cdata)->data_length = data_length;
	else
		CMD(cdata)->data_length = command.data_length + 2 + extra_bytes(command.depth);

	if (cmd_buffer->free_bytes < CMD(cdata)->data_length) {
		/* not enough TX/RX buffer space available */
		free(cdata->data);
		free(cdata);
		return -3;
	}

	/* init send buffer */
	if (cmd_code != CHIP_CMD_CREATE_CHANNEL) {
		cg_memcpy(buff, command.tx, command.data_length);
		cg_memcpy(cmd_buffer->tx_buffer + cmd_buffer->tx_offset, buff, CMD(cdata)->data_length);
	} else
		cg_memcpy(cmd_buffer->tx_buffer + cmd_buffer->tx_offset, tx, CMD(cdata)->data_length);

#if 0
	uint16_t i;
	char data[384];
	memset(data, 0, sizeof(data));
	for (i = 0; i < command.data_length; i++)
		sprintf(data, "%s%02x", data, command.tx[i]);
	applog(LOG_DEBUG, "BF16: TX -> [%s]", data);
#endif

	cmd_buffer->tx_offset  += CMD(cdata)->data_length;
	cmd_buffer->free_bytes -= CMD(cdata)->data_length;

	/* add cmd to buffer */
	LIST_PUSH_TAIL(cmd_buffer->cmd_list, cdata);	
	cmd_buffer->cmd_list->count++;

	return 0;
}

int8_t cmd_buffer_push_send_toggle(bf_cmd_buffer_t* cmd_buffer, const uint8_t depth,
		const bf_chip_address_t chip_address)
{
	bf_works_t work;
	uint8_t toggle[4] = { 0xa5, 0x00, 0x00, 0x02 };

	return cmd_buffer_push(cmd_buffer, depth, chip_address, chip_address,
			work, 0, CHIP_CMD_TOGGLE, 3, toggle);
}

int8_t cmd_buffer_push_set_clock(bf_cmd_buffer_t* cmd_buffer, const uint8_t depth,
		const bf_chip_address_t chip_address, uint8_t clock)
{
	bf_works_t work;
	uint8_t clock_buf[4];

	memset(clock_buf, 0, 4);
	gen_clock_data(clock, 1, clock_buf);

	return cmd_buffer_push(cmd_buffer, depth, chip_address, chip_address,
			work, 0, CHIP_CMD_SET_CLOCK, 3, clock_buf);
}

int8_t cmd_buffer_push_set_mask(bf_cmd_buffer_t* cmd_buffer, const uint8_t depth,
		const bf_chip_address_t chip_address, uint8_t mask)
{
	uint8_t i;
	bf_works_t work;
	uint8_t noncemask[4];

	for (i = 0; i < 4; i++)
		noncemask[i] = (mask >> (8*(4 - i - 1))) & 0xff;

	return cmd_buffer_push(cmd_buffer, depth, chip_address, chip_address,
			work, 0, CHIP_CMD_SET_MASK, 3, noncemask);
}

int8_t cmd_buffer_push_create_channel(bf_cmd_buffer_t* cmd_buffer,
		uint8_t* channel_path, uint8_t channel_length)
{
	bf_works_t work;
	bf_chip_address_t chip_address = { 0x00, 0x00, 0x00 };

	return cmd_buffer_push(cmd_buffer, 0, chip_address, chip_address,
			work, 0, CHIP_CMD_CREATE_CHANNEL, channel_length, channel_path);
}

int8_t cmd_buffer_push_destroy_channel(bf_cmd_buffer_t* cmd_buffer, const uint8_t depth)
{
	bf_works_t work;
	bf_chip_address_t chip_address = { 0x00, 0x00, 0x0f };

	return cmd_buffer_push(cmd_buffer, depth, chip_address, chip_address,
			work, 0, CHIP_CMD_TASK_SWITCH, 0, NULL);
}

bool match_nonce(uint32_t nonce, uint32_t mask, uint8_t nbits)
{
	uint32_t fixed_mask = (uint32_t)(pow(2, nbits) - 1);
	return ((nonce & fixed_mask) == (mask & fixed_mask));
}

uint8_t find_nonces(uint32_t* curr_nonces, uint32_t* prev_nonces, uint32_t* valid_nonces)
{
	uint8_t i, j;
	uint8_t found  = 0;
	uint8_t nonces = 0;
	uint8_t diff = 0;

	uint32_t found_nonces[12];
	memset(found_nonces, 0, sizeof(found_nonces));

	for (i = 0; i < 12; i++) {
		if (((curr_nonces[i] & 0x0fffffff) != 0x0fffffff) &&
			(curr_nonces[i] != prev_nonces[i])) {
			found_nonces[found++] = curr_nonces[i];
		}

		if (((curr_nonces[i] & 0x0fffffff) == 0x0fffffff) &&
			(curr_nonces[i] != prev_nonces[i]))
			diff++;
	}

	for (i = 0; i < found; i++) {
		if (found_nonces[i] == 0x00000000)
			continue;

		for (j = i; j < found; j++) {
			if ((j != i) && (found_nonces[i] == found_nonces[j]))
				found_nonces[j] = 0x00000000;
		}

		valid_nonces[nonces++] = found_nonces[i];
	}

	return nonces;
}

int8_t cmd_buffer_pop(bf_cmd_buffer_t* cmd_buffer, bf_cmd_status_t* cmd_status, uint32_t* nonces)
{
	if (cmd_buffer == NULL)
		return -1;

	if (cmd_buffer->status != EXECUTED)
		return -2;

	if (cmd_buffer->cmd_list->head == NULL)
		return -3;

	uint8_t buff[192];
	bf_command_t chip_command;
	memset(buff, 0, sizeof(buff));
	memset(chip_command.rx, 0, sizeof(chip_command.rx));

	/* extract command from list */
	bf_data_t* cdata = cmd_buffer->cmd_list->head;

	chip_command.cmd_code             = CMD(cdata)->cmd_code;
	chip_command.depth                = CMD(cdata)->depth;
	chip_command.data_length          = CMD(cdata)->data_length;
	chip_command.status               = 0;
	chip_command.checksum             = CMD(cdata)->checksum;
	chip_command.nonce_checksum       = 0;
	chip_command.checksum_error       = false;
	chip_command.nonce_checksum_error = false;

	/* extract chip return data */
	cg_memcpy(buff, cmd_buffer->rx_buffer + cmd_buffer->rx_offset, CMD(cdata)->data_length);
	cmd_buffer->rx_offset += CMD(cdata)->data_length;
	if (CMD(cdata)->cmd_code & CHIP_CMD_READ_NONCE) {
		cg_memcpy(chip_command.rx, buff + CMD(cdata)->data_length - (49 + 2 + extra_bytes(chip_command.depth)),
				49 + 2 + extra_bytes(chip_command.depth));
		memset(nonces, 0, 12 * sizeof(uint32_t));
		analyze_rx_data(&chip_command, cmd_status, nonces);
	} else if (CMD(cdata)->cmd_code == CHIP_CMD_CREATE_CHANNEL) {
		cg_memcpy(chip_command.rx, buff, CMD(cdata)->data_length);
	} else {
		cg_memcpy(chip_command.rx, buff + CMD(cdata)->data_length - (2 + extra_bytes(chip_command.depth)),
				2 + extra_bytes(chip_command.depth));
		analyze_rx_data(&chip_command, cmd_status, NULL);
	}

	/* prepare cmd_status */
	cg_memcpy(&cmd_status->chip_address, &CMD(cdata)->chip_address, sizeof(bf_chip_address_t));
	cg_memcpy(&cmd_status->src_address,  &CMD(cdata)->src_address,  sizeof(bf_chip_address_t));
	cg_memcpy(&cmd_status->work,         &CMD(cdata)->work,         sizeof(bf_works_t));
	cmd_status->id       = CMD(cdata)->id;
	cmd_status->cmd_code = CMD(cdata)->cmd_code;

	/* push memory back to free cmd list */
	LIST_POP_HEAD(cmd_buffer->cmd_list);
	cmd_buffer->cmd_list->count--;
	free(cdata->data);
	free(cdata);

	return 0;
}

int8_t cmd_buffer_exec(spi_channel_id_t spi_channel, bf_cmd_buffer_t* cmd_buffer)
{
	if (cmd_buffer == NULL)
		return -1;

	if (cmd_buffer->status == TX_READY) {
		device_spi_txrx(spi_channel, cmd_buffer->tx_buffer, cmd_buffer->rx_buffer, cmd_buffer->tx_offset);
		cmd_buffer->status = EXECUTED;
	} else
		return -2;

	return 0;
}

/* BF16 command primitives */
uint8_t gen_clock_data(uint8_t clock, uint8_t prescaler, uint8_t data[4])
{
	uint8_t i;
	uint32_t data32 = 0x00000000;

	if (clock > 0x3f)
		return -1;

	if ((prescaler != 0) && (prescaler != 1))
		return -1;

	uint32_t magic_const = 0x38;
	uint32_t prescaler1 = prescaler;
	uint32_t clock1 = clock;
	uint32_t prescaler2 = prescaler;
	uint32_t clock2 = clock;

	magic_const <<= 20;

	if (prescaler == 1) {
		prescaler1 <<= 19;
		prescaler2 <<= 12;
	}

	clock1 <<= 13;
	clock2 <<= 6;

	data32 = magic_const | prescaler1 | clock1 | prescaler2 | clock2;
	for (i = 0; i < 4; i++)
		data[i] = (data32 >> (8*(4 - i - 1))) & 0xff;

	return 0;
}

#ifdef FLIP_BITS
static uint32_t flip_bits(uint32_t data, uint8_t nbits)
{
	uint32_t ret = 0x00000000;
	uint8_t i;

	for (i = 0; i < nbits; i++)
		ret |= (((data >> i) & 0x1) << (nbits - (i + 1)));

	return ret;
}
#endif

uint32_t gen_mask(uint32_t nonce, uint8_t nbits)
{
	uint32_t mask = 0x00000000;

	uint32_t mask_code = (nbits << 16);

	/* highest 16 bits of nonce counter */
	uint32_t nonce_code = (nonce & 0x0007ffff);
#ifdef FLIP_BITS
	uint32_t nonce_cntr = flip_bits(nonce_code, 19);
	nonce_code = (flip_bits(nonce_cntr - 2, 19) ^ 0xaaaaaaaa);
	mask = (mask_code | (nonce_code & (uint32_t)(pow(2, nbits) - 1)));
#else
	nonce_code = ((nonce_code ^ 0xaaaaaaaa) & (uint32_t)(pow(2, nbits) - 1));
	mask = (mask_code | nonce_code);
#endif

	return mask;
}

void ms3steps16(uint32_t* p, uint32_t* w, uint32_t* task)
{
	uint32_t a, b, c, d, e, f, g, h, new_e, new_a;
	uint8_t 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 = w[i] + sha256_k[i] + h + CH(e,f,g) + SHA256_F2(e) + d;
		new_a = w[i] + 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;
	}

	task[18] = ntohl(a ^ 0xaaaaaaaa);
	task[17] = ntohl(b ^ 0xaaaaaaaa);
	task[16] = ntohl(c ^ 0xaaaaaaaa);
	task[15] = ntohl(d ^ 0xaaaaaaaa);
	task[11] = ntohl(e ^ 0xaaaaaaaa);
	task[10] = ntohl(f ^ 0xaaaaaaaa);
	task[9]  = ntohl(g ^ 0xaaaaaaaa);
	task[8]  = ntohl(h ^ 0xaaaaaaaa);
}

uint8_t gen_task_data(uint32_t* midstate, uint32_t merkle, uint32_t ntime,
		uint32_t nbits, uint32_t mask, uint8_t* task)
{
	uint8_t  i;
	uint32_t tmp;
	uint32_t w[3];

	w[0] = merkle;
	w[1] = ntime;
	w[2] = nbits;

	for (i = 0; i < 8; i++) {
		tmp = midstate[i];
		tmp ^= 0xaaaaaaaa;
		tmp = ntohl(tmp);
		cg_memcpy(task + i*4, &tmp, sizeof(tmp));
	}

	ms3steps16(midstate, w, (uint32_t*)task);

	for (i = 0; i < 3; i++) {
		tmp = w[i];
		tmp ^= 0xaaaaaaaa;
		tmp = ntohl(tmp);
		cg_memcpy(task + (12 + i)*4, &tmp, sizeof(tmp));
	}

	mask = ntohl(mask);
	cg_memcpy(task + 19*4, &mask, sizeof(mask));

	return 0;
}

uint8_t spi_command_init(bf_command_t* command, const uint8_t depth,
		const bf_chip_address_t chip_address, const bf_cmd_code_t cmd_code,
		const uint8_t data_length, const uint8_t* tx)
{
	uint8_t i;

	memset(command->tx, 0, sizeof(command->tx));
	memset(command->rx, 0, sizeof(command->rx));

	command->tx[0] = 0x01;
	command->data_length = 1;

	if ((chip_address.chip_id > 10) && (chip_address.chip_id != 0x0f))
		return 1;
	else {
		cg_memcpy(&command->chip_address, &chip_address, sizeof(bf_chip_address_t));
		command->tx[1] = (command->chip_address.chip_id << 4);
		command->data_length++;
	}

	command->depth = depth;

	command->cmd_code = cmd_code;
	command->tx[2] = command->cmd_code;
	command->data_length++;

	if (data_length <= 79) {
		command->tx[3] = data_length;
		command->data_length++;
	} else
		return 1;

	/* fill TX data */
	if (data_length == 0) {
		command->tx[4] = 0x00;
		command->data_length++;
	} else if (tx != NULL) {
		cg_memcpy(command->tx + 4, tx, data_length + 1);
		command->data_length += (data_length + 1);
	} else
		return 1;

	/* calculate checksum */
	command->checksum = 0;
	command->nonce_checksum = 0;
	for (i = 2; i < command->data_length; i++)
		command->checksum += command->tx[i];

	command->checksum_error       = false;
	command->nonce_checksum_error = false;

	return 0;
}

uint8_t spi_command_exec(spi_channel_id_t spi_channel, bf_command_t* command, uint32_t* nonces)
{
	uint8_t buff[192];
	uint8_t res = 0;
	bf_cmd_status_t cmd_status;

	if (command->cmd_code & CHIP_CMD_READ_NONCE) {
		memset(buff, 0x00, command->data_length + 49 + 2 + extra_bytes(command->depth));
		cg_memcpy(buff, command->tx, command->data_length);
		device_spi_transfer(spi_channel, buff, command->data_length + 49 + 2 + extra_bytes(command->depth));
		cg_memcpy(command->rx, buff + command->data_length, 49 + 2 + extra_bytes(command->depth));

#if 0
		uint16_t i;
		char data[256];
		memset(data, 0, sizeof(data));
		for (i = 0; i < command->data_length; i++)
			sprintf(data, "%s%02x", data, command->tx[i]);
		applog(LOG_DEBUG, "BF16: TX -> [%s]", data);
#endif

		return analyze_rx_data(command, &cmd_status, nonces);
	} else {
		memset(buff, 0x00, command->data_length + 2 + extra_bytes(command->depth));
		cg_memcpy(buff, command->tx, command->data_length);
		device_spi_transfer(spi_channel, buff, command->data_length + 2 + extra_bytes(command->depth));
		cg_memcpy(command->rx, buff + command->data_length, 2 + extra_bytes(command->depth));

		if (opt_bf16_test_chip != NULL) {
			uint16_t i;
			char data[256];
			memset(data, 0, sizeof(data));
			for (i = 0; i < command->data_length; i++)
				sprintf(data, "%s%02x", data, command->tx[i]);
			applog(LOG_NOTICE, "BF16: TX -> [%s]", data);
		}

		return analyze_rx_data(command, &cmd_status, nonces);
	}

	return res;
}

/* dynamic work list primitives */
bf_list_t* workd_list_init(void)
{
	bf_list_t* list = cgmalloc(sizeof(bf_list_t));
	list->head = NULL;
	list->tail = NULL;
	list->count = 0;
	pthread_mutex_init(&list->lock, NULL);

	return list;
}

int8_t workd_list_deinit(bf_list_t* list, struct cgpu_info *bitfury)
{
	if (list == NULL)
		return -1;

	/* free work list */
	L_LOCK(list);
	while (list->head != NULL) {
		bf_data_t* wdata = list->head;
		LIST_POP_HEAD(list);

		if (WORKD(wdata)->rolled)
			free_work(WORKD(wdata)->work);
		else
			work_completed(bitfury, WORKD(wdata)->work);

		free(wdata);
	}
	L_UNLOCK(list);

	pthread_mutex_destroy(&list->lock);
	list->count = 0;
	free(list);

	return 0;
}

int8_t workd_list_push(bf_list_t* list, bf_workd_t* work)
{
	if ((list == NULL) || (work == NULL))
		return -1;

	bf_data_t* wdata = cgmalloc(sizeof(bf_data_t));
	wdata->data = work;
	wdata->next = NULL;
	wdata->prev = NULL;

	LIST_PUSH_TAIL(list, wdata);
	list->count++;

	return 0;
}

int8_t workd_list_pop(bf_list_t* list, struct cgpu_info *bitfury)
{
	if (list == NULL)
		return -1;

	bf_data_t* wdata = list->head;
	if (wdata != NULL) {
		LIST_POP_HEAD(list);	

		if (WORKD(wdata)->rolled)
			free_work(WORKD(wdata)->work);
		else
			work_completed(bitfury, WORKD(wdata)->work);

		list->count--;
		free(wdata->data);
		free(wdata);
	} else
		return -1;

	return 0;
}

int8_t workd_list_remove(bf_list_t* list, bf_works_t* works)
{
	if (list == NULL)
		return -1;

	bf_data_t* wdata = list->head;
	if (wdata != NULL) {
		LIST_POP_HEAD(list);	

		cg_memcpy(&works->work,    WORKD(wdata)->work,     sizeof(struct work));
		cg_memcpy(&works->payload, &WORKD(wdata)->payload, sizeof(bf_payload_t));

		list->count--;
		free(wdata);
	} else
		return -1;

	return 0;
}

/* nonces list primitives */
bf_list_t* nonce_list_init(void)
{
	bf_list_t* list = cgmalloc(sizeof(bf_list_t));
	list->head = NULL;
	list->tail = NULL;
	list->count = 0;
	pthread_mutex_init(&list->lock, NULL);

	return list;
}

int8_t nonce_list_deinit(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	/* free nonce list */
	L_LOCK(list);
	while (list->head != NULL) {
		bf_data_t* ndata = list->head;
		LIST_POP_HEAD(list);
		free(ndata->data);
		free(ndata);
	}
	L_UNLOCK(list);

	pthread_mutex_destroy(&list->lock);
	list->count = 0;
	free(list);
	
	return 0;
}

int8_t nonce_list_push(bf_list_t* list, uint32_t nonce)
{
	if (list == NULL)
		return -1;

	/* find nonce duplicates */
	bf_data_t* ndata = list->head;
	while (ndata != NULL) {
		if (NONCE(ndata)->nonce == nonce)
			return -1;
		ndata = ndata->next;
	}

	ndata = cgmalloc(sizeof(bf_data_t));
	ndata->data = cgmalloc(sizeof(bf_nonce_t));
	NONCE(ndata)->nonce = nonce;
	ndata->next = NULL;
	ndata->prev = NULL;

	LIST_PUSH_TAIL(list, ndata);
	list->count++;

	return 0;
}

uint32_t nonce_list_pop(bf_list_t* list)
{
	uint32_t nonce = 0;

	bf_data_t* ndata = list->head;
	if (ndata != NULL) {
		nonce = NONCE(ndata)->nonce;
		LIST_POP_HEAD(list);	
		list->count--;
		free(ndata->data);
		free(ndata);
	} else
		return -1;

	return nonce;
}

/* renoncework list primitives */
bf_list_t* renoncework_list_init(void)
{
	bf_list_t* list = cgmalloc(sizeof(bf_list_t));
	list->head = NULL;
	list->tail = NULL;
	list->count = 0;
	pthread_mutex_init(&list->lock, NULL);

	return list;
}

int8_t renoncework_list_deinit(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	/* free renoncework list */
	L_LOCK(list);
	while (list->head != NULL) {
		bf_data_t* rnwdata = list->head;
		LIST_POP_HEAD(list);

		free(rnwdata->data);
		free(rnwdata);
	}
	L_UNLOCK(list);

	pthread_mutex_destroy(&list->lock);
	list->count = 0;
	free(list);

	return 0;
}

int8_t renoncework_list_push(bf_list_t* list, bf_chip_address_t src_address, uint32_t nonce)
{
	if (list == NULL)
		return -1;

	bf_data_t* rnwdata = cgmalloc(sizeof(bf_data_t));
	rnwdata->data = cgmalloc(sizeof(bf_renoncework_t));
	rnwdata->next = NULL;
	rnwdata->prev = NULL;

	cg_memcpy(&RENONCEWORK(rnwdata)->src_address, &src_address, sizeof(bf_chip_address_t));
	RENONCEWORK(rnwdata)->nonce = nonce;

	LIST_PUSH_TAIL(list, rnwdata);
	list->count++;

	return 0;
}

int8_t renoncework_list_pop(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	bf_data_t* rnwdata = list->head;
	if (rnwdata != NULL) {
		LIST_POP_HEAD(list);	
		list->count--;
		free(rnwdata->data);
		free(rnwdata);
	} else
		return -1;

	return 0;
}

/* noncework list primitives */
bf_list_t* noncework_list_init(void)
{
	bf_list_t* list = cgmalloc(sizeof(bf_list_t));
	list->head = NULL;
	list->tail = NULL;
	list->count = 0;
	pthread_mutex_init(&list->lock, NULL);

	return list;
}

int8_t noncework_list_deinit(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	/* free noncework list */
	L_LOCK(list);
	while (list->head != NULL) {
		bf_data_t* nwdata = list->head;
		LIST_POP_HEAD(list);

		free(nwdata->data);
		free(nwdata);
	}
	L_UNLOCK(list);

	pthread_mutex_destroy(&list->lock);
	list->count = 0;
	free(list);

	return 0;
}

int8_t noncework_list_push(bf_list_t* list, bf_chip_address_t chip_address,
		bf_chip_address_t src_address, bf_works_t cwork, bf_works_t owork, uint32_t nonce)
{
	if (list == NULL)
		return -1;

	bf_data_t* nwdata = cgmalloc(sizeof(bf_data_t));
	nwdata->data = cgmalloc(sizeof(bf_noncework_t));
	nwdata->next = NULL;
	nwdata->prev = NULL;

	cg_memcpy(&NONCEWORK(nwdata)->cwork, &cwork, sizeof(bf_works_t));
	cg_memcpy(&NONCEWORK(nwdata)->owork, &owork, sizeof(bf_works_t));
	cg_memcpy(&NONCEWORK(nwdata)->chip_address, &chip_address, sizeof(bf_chip_address_t));
	cg_memcpy(&NONCEWORK(nwdata)->src_address,  &src_address,  sizeof(bf_chip_address_t));
	NONCEWORK(nwdata)->nonce = nonce;

	LIST_PUSH_TAIL(list, nwdata);
	list->count++;

	return 0;
}

int8_t noncework_list_pop(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	bf_data_t* nwdata = list->head;
	if (nwdata != NULL) {
		LIST_POP_HEAD(list);	
		list->count--;
		free(nwdata->data);
		free(nwdata);
	} else
		return -1;

	return 0;
}

/* renonce list primitives */
bf_list_t* renonce_list_init(void)
{
	bf_list_t* list = cgmalloc(sizeof(bf_list_t));
	list->head = NULL;
	list->tail = NULL;
	list->count = 0;
	pthread_mutex_init(&list->lock, NULL);

	return list;
}

int8_t renonce_list_deinit(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	/* free renonce list */
	L_LOCK(list);
	while (list->head != NULL) {
		bf_data_t* rdata = list->head;
		LIST_POP_HEAD(list);

		free(rdata->data);
		free(rdata);
	}
	L_UNLOCK(list);

	pthread_mutex_destroy(&list->lock);
	list->count = 0;
	free(list);

	return 0;
}

int8_t renonce_list_push(bf_list_t* list, uint32_t id, uint32_t nonce, bf_chip_address_t src_address,
		bf_works_t cwork, bf_works_t owork)
{
	if (list == NULL)
		return -1;

	bf_data_t* rdata = cgmalloc(sizeof(bf_data_t));
	rdata->data = cgmalloc(sizeof(bf_renonce_t));
	rdata->next = NULL;
	rdata->prev = NULL;

	cg_memcpy(&RENONCE(rdata)->cwork, &cwork, sizeof(bf_works_t));
	cg_memcpy(&RENONCE(rdata)->owork, &owork, sizeof(bf_works_t));
	cg_memcpy(&RENONCE(rdata)->src_address, &src_address, sizeof(bf_chip_address_t));
	RENONCE(rdata)->id    = id;
	RENONCE(rdata)->nonce = nonce;
	RENONCE(rdata)->stage = RENONCE_STAGE0;
	RENONCE(rdata)->sent      = false;
	RENONCE(rdata)->received  = false;
	RENONCE(rdata)->match     = false;

	LIST_PUSH_TAIL(list, rdata);
	list->count++;

	return 0;
}

int8_t renonce_list_pop(bf_list_t* list)
{
	if (list == NULL)
		return -1;

	bf_data_t* rdata = list->head;
	if (rdata != NULL) {
		LIST_POP_HEAD(list);	
		list->count--;
		free(rdata->data);
		free(rdata);
	} else
		return -1;

	return 0;
}

int8_t renonce_list_remove(bf_list_t* list, bf_data_t* rdata)
{
	if (list == NULL)
		return -1;

	if (rdata != NULL) {
		LIST_REMOVE(list, rdata);
		list->count--;
		free(rdata->data);
		free(rdata);
	} else
		return -1;

	return 0;
}