bf16 Bitfury16
bf16 Bitfury16
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"
}
};
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;
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;
if (i == 48)
break;
nonce = 0x00000000;
}
#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
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;
}
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 (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;
}
free(channel_path_buff);
return res;
}
device_ctrl_transfer(spi_channel, 0, F_RST);
}
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->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;
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;
}
free(cmd_buffer->cmd_list);
cmd_buffer->free_bytes = CMD_BUFFER_LEN;
cmd_buffer->tx_offset = 0;
cmd_buffer->rx_offset = 0;
cmd_buffer->status = EMPTY;
return 0;
}
cmd_buffer->cmd_list->count = 0;
cmd_buffer->free_bytes = CMD_BUFFER_LEN;
cmd_buffer->tx_offset = 0;
cmd_buffer->rx_offset = 0;
cmd_buffer->status = EMPTY;
return 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 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;
return 0;
}
memset(clock_buf, 0, 4);
gen_clock_data(clock, 1, clock_buf);
uint32_t found_nonces[12];
memset(found_nonces, 0, sizeof(found_nonces));
valid_nonces[nonces++] = found_nonces[i];
}
return nonces;
}
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));
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;
/* 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;
return 0;
}
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;
}
if (prescaler == 1) {
prescaler1 <<= 19;
prescaler2 <<= 12;
}
return 0;
}
#ifdef FLIP_BITS
static uint32_t flip_bits(uint32_t data, uint8_t nbits)
{
uint32_t ret = 0x00000000;
uint8_t i;
return ret;
}
#endif
return mask;
}
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;
}
w[0] = merkle;
w[1] = ntime;
w[2] = nbits;
ms3steps16(midstate, w, (uint32_t*)task);
mask = ntohl(mask);
cg_memcpy(task + 19*4, &mask, sizeof(mask));
return 0;
}
memset(command->tx, 0, sizeof(command->tx));
memset(command->rx, 0, sizeof(command->rx));
command->tx[0] = 0x01;
command->data_length = 1;
command->depth = depth;
command->cmd_code = cmd_code;
command->tx[2] = command->cmd_code;
command->data_length++;
/* 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;
}
#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
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 res;
}
return 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;
}
LIST_PUSH_TAIL(list, wdata);
list->count++;
return 0;
}
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;
}
list->count--;
free(wdata);
} else
return -1;
return 0;
}
return list;
}
pthread_mutex_destroy(&list->lock);
list->count = 0;
free(list);
return 0;
}
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;
}
return nonce;
}
return list;
}
free(rnwdata->data);
free(rnwdata);
}
L_UNLOCK(list);
pthread_mutex_destroy(&list->lock);
list->count = 0;
free(list);
return 0;
}
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;
}
return 0;
}
return list;
}
free(nwdata->data);
free(nwdata);
}
L_UNLOCK(list);
pthread_mutex_destroy(&list->lock);
list->count = 0;
free(list);
return 0;
}
LIST_PUSH_TAIL(list, nwdata);
list->count++;
return 0;
}
return 0;
}
return list;
}
free(rdata->data);
free(rdata);
}
L_UNLOCK(list);
pthread_mutex_destroy(&list->lock);
list->count = 0;
free(list);
return 0;
}
return 0;
}
return 0;
}
if (rdata != NULL) {
LIST_REMOVE(list, rdata);
list->count--;
free(rdata->data);
free(rdata);
} else
return -1;
return 0;
}