Driver Bitfury16

#include "config.
h"
#include "math.h"
#include "miner.h"
#include "bf16-communication.h"
#include "bf16-ctrldevice.h"
#include "bf16-mspcontrol.h"
#include "bf16-spidevice.h"
#include "bf16-uartdevice.h"
#include "driver-bitfury16.h"
#ifdef FILELOG
#define LOGFILE "/var/log/cgminer.log"
#endif
#define DISABLE_SEND_CMD_ERROR
#define POWER_WAIT_INTERVAL 100000

#define RENONCE_SEND 5
#define RENONCE_STAGE2_LIMIT 80
#define RENONCE_STAGE3_LIMIT 60
#define RENONCE_QUEUE_LEN 100
#define RENONCE_COUNT 29
/* chip nonce queue len */

#define NONCE_CHIP_QUEUE_LEN 7
#define RENONCE_CHIP_QUEUE_LEN 40
#define WORK_TIMEOUT 2.0
/* statistics intervals */
#define AVG_TIME_DELTA 5.0
#define AVG_TIME_INTERVAL 5.0
/* power chain alarm interval */

#define ICHAIN_ALARM_INTERVAL 60
#define U_LOSS 0.2
/* power chain reenable timeout */

#define CHAIN_REENABLE_INTERVAL 10
#define CHAIN_WORK_INTERVAL 1200
/* disable chip if no good nonces received during CHIP_FAILING_INTERVAL */

#define RENONCE_CHIP_FAILING_INTERVAL 15.0
#define CHIP_FAILING_INTERVAL 30.0
#define CHIP_RECOVERY_INTERVAL 5.0
/* chip is considered to be failed after CHIP_ERROR_FAIL_LIMIT recovery attempts */

#define CHIP_ERROR_FAIL_LIMIT 10
/* this value should be less than CHIP_ERROR_FAIL_LIMIT */
#define RENONCE_CHIP_ERROR_FAIL_LIMIT 8
#define CHIP_ERROR_LIMIT 5
#define CHIP_TASK_STATUS_INTERVAL 7000

#define CHIP_TASK_SWITCH_INTERVAL 5000000
#define CHIP_RESTART_LIMIT 120

/* alarm intervals */
#define LED_GREEN_INTERVAL 1000000
#define LED_RED_INTERVAL 1000000
#define LED_RED_NET_INTERVAL 500000
#define BUZZER_INTERVAL 1000000
/* threads delay */
#define CHIPWORKER_DELAY 1000000
#define NONCEWORKER_DELAY 30000
#define RENONCEWORKER_DELAY 30000
#define HWMONITOR_DELAY 1000000
#define STATISTICS_DELAY 400000
#define ALARM_DELAY 500000
/* hold 3 works for each chip */

#define WORK_QUEUE_LEN 3 * CHIPS_NUM
/* set clock to all chips and exit */

bool opt_bf16_set_clock = false;
/* enable board mining statistics output */

bool opt_bf16_stats_enabled = false;
/* disable automatic power management */

bool opt_bf16_power_management_disabled = false;
/* renonce configuration */
int opt_bf16_renonce = RENONCE_ONE_CHIP;
/* chip clock value */

char* opt_bf16_clock = NULL;
uint8_t bf16_chip_clock = 0x32;
/* renonce chip clock value */

char* opt_bf16_renonce_clock = NULL;
uint8_t bf16_renonce_chip_clock = 0x2d;
/* fan speed */
int opt_bf16_fan_speed = -1;
/* target temp */
int opt_bf16_target_temp = -1;
/* alarm temp */
int opt_bf16_alarm_temp = -1;
/* test chip communication */

char* opt_bf16_test_chip = NULL;
/* number of bits to fixate */

static uint32_t mask_bits = 10;
/* default chip mask */

static uint32_t mask = 0x00000000;
/* initial pid state */

static bf_pid_t pid = {
.i_state = 0,
.i_max = 300,
.i_min = -10,
};
#ifdef MINER_X5
bool opt_bf16_manual_pid_enabled = false;
bool manual_pid_enabled = false;
static bf_bcm250_map_t bcm250_map[CHIPBOARD_NUM][BCM250_NUM] = {

{
{
.channel_path = { BF250_LOCAL, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN1, BF250_LOCAL },
.chips_num = 4
},
{
}
},
{
{
.channel_path = { BF250_LOCAL, BF250_NONE },
},
{
.chips_num = 4
},
{
}
}
};
#endif
#ifdef MINER_X6
bool opt_bf16_manual_pid_disabled = false;
bool manual_pid_enabled = false;
static bf_bcm250_map_t bcm250_map[CHIPBOARD_NUM][BCM250_NUM] = {

{
{
.channel_path = { BF250_LOCAL, BF250_NONE, BF250_NONE,
BF250_NONE },
},
{
.channel_path = { BF250_CHAN1, BF250_LOCAL, BF250_NONE,
BF250_NONE },
},
{
BF250_NONE },
.last_good_chip = 4,
.chips_num = 4
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_LOCAL,
BF250_NONE },
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_CHAN1,
BF250_LOCAL },
},
{
BF250_LOCAL },
.chips_num = 4
}
},
{
{
.channel_path = { BF250_LOCAL, BF250_NONE, BF250_NONE,
BF250_NONE },
},
{
BF250_NONE },
},
{
BF250_NONE },
.chips_num = 4
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_LOCAL,
BF250_NONE },
},
{
BF250_LOCAL },
},
{
BF250_LOCAL },
.chips_num = 4
}
}
};
#endif
/* each array element contains chip address assosiated to corresponting chipboard *

* e.g. first array element - renonce chip address for the first chipboard and so *
* on */
static bf_chip_address_t renonce_chip_address[CHIPBOARD_NUM] = {
{
.board_id = 0,
.bcm250_id = 0,
.chip_id = 0
},
{
.board_id = 1,
.bcm250_id = 0,
.chip_id = 0
}
};
#ifdef FILELOG
static int filelog(struct bitfury16_info *info, const char* format, ...)
{
char fmt[1024];
char datetime[64];
struct timeval tv = {0, 0};
struct tm *tm;
if (info->logfile == NULL)
return -1;
gettimeofday(&tv, NULL);
const time_t tmp_time = tv.tv_sec;
int ms = (int)(tv.tv_usec / 1000);
tm = localtime(&tmp_time);
snprintf(datetime, sizeof(datetime), " [%d-%02d-%02d %02d:%02d:%02d.%03d] ",

tm->tm_year + 1900,
tm->tm_mon + 1,
tm->tm_mday,
tm->tm_hour,
tm->tm_min,
tm->tm_sec, ms);
memset(fmt, 0, sizeof(fmt));
sprintf(fmt, "%s%s\n", datetime, format);
va_list args;
va_start(args, format);
mutex_lock(&info->logfile_mutex);
vfprintf(info->logfile, fmt, args);
fflush(info->logfile);
mutex_unlock(&info->logfile_mutex);
va_end(args);
return 0;
}
#endif
static double timediff(struct timeval time1, struct timeval time2)

{
double time1_val = 1000000 * time1.tv_sec + time1.tv_usec;
double time2_val = 1000000 * time2.tv_sec + time2.tv_usec;
return (double)(time2_val - time1_val) / 1000000.0;

}
static uint32_t timediff_us(struct timeval time1, struct timeval time2)

{
uint32_t time1_val = 1000000 * time1.tv_sec + time1.tv_usec;
uint32_t time2_val = 1000000 * time2.tv_sec + time2.tv_usec;
return (time2_val - time1_val);

}
static void get_average(float* average, float delta, float time_diff, float

interval)
{
float ftotal, fprop;
fprop = 1.0 - 1 / (exp((float)time_diff/(float)interval));

ftotal = 1.0 + fprop;
*average += (delta / time_diff * fprop);
*average /= ftotal;
}
static uint8_t renonce_chip(bf_chip_address_t chip_address)

{
uint8_t board_id = chip_address.board_id;
if ((renonce_chip_address[board_id].bcm250_id == chip_address.bcm250_id) &&
(renonce_chip_address[board_id].chip_id == chip_address.chip_id))
return 1;
return 0;
}
static void get_next_chip_address(struct bitfury16_info *info, bf_chip_address_t*

chip_address)
{
uint8_t board_id = chip_address->board_id;
uint8_t bcm250_id = chip_address->bcm250_id;
uint8_t chip_id = chip_address->chip_id;
uint8_t last_good_chip = info-

>chipboard[board_id].bcm250[bcm250_id].last_good_chip - 1;
if (last_good_chip == chip_id) {
#ifdef MINER_X5
bcm250_id = (bcm250_id + 1) % BCM250_NUM;
chip_id = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
#endif
#ifdef MINER_X6
if (opt_bf16_power_management_disabled == false) {
bcm250_id = (bcm250_id + 1) % BCM250_NUM;
/* do not set bcm250_id to disabled chain */

/* second power chain disabled */
if ((info->chipboard[board_id].p_chain2_enabled == 0) &&
(info->chipboard[board_id].power2_disabled == true) &&
(bcm250_id >= BCM250_NUM / 2) && (bcm250_id < BCM250_NUM))
{
bcm250_id = 0;
}
chip_id = info-
>chipboard[board_id].bcm250[bcm250_id].first_good_chip;
} else {
chip_id = info-
}
#endif
} else
chip_id++;
chip_address->bcm250_id = bcm250_id;
chip_address->chip_id = chip_id;
}
static int8_t change_renonce_chip_address(struct cgpu_info *bitfury,

bf_chip_address_t chip_address)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury-
>device_data);

uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
bf_chip_address_t new_chip_address = { board_id, bcm250_id, chip_id };
bool found = false;

uint8_t chip_count = 0;
while (true) {
get_next_chip_address(info, &new_chip_address);
chip_count++;
uint8_t new_board_id = new_chip_address.board_id;

uint8_t new_bcm250_id = new_chip_address.bcm250_id;
uint8_t new_chip_id = new_chip_address.chip_id;
/* enabled chip found */

if (info-
>chipboard[new_board_id].bcm250[new_bcm250_id].chips[new_chip_id].status !=
DISABLED) {
found = true;
break;
}
/* we have run full loop chipboard */

#ifdef MINER_X5
if (chip_count == info->chipboard[board_id].chips_num)
break;
#endif
#ifdef MINER_X6
if ((info->chipboard[board_id].p_chain2_enabled == 0) &&
(info->chipboard[board_id].power2_disabled == true)) {
if (chip_count == info->chipboard[board_id].chips_num / 2)
break;
} else {
break;
}
} else {
break;
}
#endif
}
if ((found == true) &&

(memcmp(&new_chip_address, &renonce_chip_address[board_id],
sizeof(bf_chip_address_t)) != 0)) {
board_id = new_chip_address.board_id;
bcm250_id = new_chip_address.bcm250_id;
chip_id = new_chip_address.chip_id;
renonce_chip_address[board_id].bcm250_id = bcm250_id;
renonce_chip_address[board_id].chip_id = chip_id;
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status
= UNINITIALIZED;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = time(NULL);
gettimeofday(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time, NULL);
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count = 0;
applog(LOG_NOTICE, "%s: changed renonce chip address to: [%d:%d:%2d]",

bitfury->drv->name,
board_id, bcm250_id, chip_id);
#ifdef FILELOG
filelog(info, "%s: changed renonce chip address to: [%d:%d:%2d]",
bitfury->drv->name,
#endif
return 0;
} else {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status =
DISABLED;
applog(LOG_NOTICE, "%s: failed to find working renonce chip.

disabling...",
bitfury->drv->name);
#ifdef FILELOG
filelog(info, "%s: failed to find working renonce chip. disabling...",
#endif
return -1;
}
}
static void increase_good_nonces(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_good_dx++;
info->chipboard[board_id].bcm250[bcm250_id].nonces_good_dx++;
info->chipboard[board_id].nonces_good_dx++;
info->nonces_good_dx++;
}
static void increase_bad_nonces(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_bad_dx++;
info->chipboard[board_id].bcm250[bcm250_id].nonces_bad_dx++;
info->chipboard[board_id].nonces_bad_dx++;
info->nonces_bad_dx++;
}
static void increase_re_nonces(struct bitfury16_info *info, bf_chip_address_t
chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_dx++;
info->chipboard[board_id].bcm250[bcm250_id].nonces_re_dx++;
info->chipboard[board_id].nonces_re_dx++;
info->nonces_re_dx++;
}
static void increase_re_good_nonces(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_good_dx+
+;
if (renonce_chip(chip_address) == 0) {
info->chipboard[board_id].bcm250[bcm250_id].nonces_re_good_dx++;
info->chipboard[board_id].nonces_re_good_dx++;
info->nonces_re_good_dx++;
}
}
static void increase_re_bad_nonces(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_bad_dx+
+;
if (renonce_chip(chip_address) == 0) {
info->chipboard[board_id].bcm250[bcm250_id].nonces_re_bad_dx++;
info->chipboard[board_id].nonces_re_bad_dx++;
info->nonces_re_bad_dx++;
}
}
static void increase_total_nonces(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_dx++;
if ((renonce_chip(chip_address) == 0) ||
(opt_bf16_renonce == RENONCE_DISABLED)) {
info->chipboard[board_id].bcm250[bcm250_id].nonces_dx++;
info->chipboard[board_id].nonces_dx++;
info->nonces_dx++;
}
}
static void increase_task_switch(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_switch_dx++;
info->chipboard[board_id].bcm250[bcm250_id].task_switch_dx++;
info->chipboard[board_id].task_switch_dx++;
info->task_switch_dx++;
}
static void increase_errors(struct bitfury16_info *info, bf_chip_address_t

chip_address)
{
/* update timing interval */

time_t curr_time = time(NULL);
if (curr_time - info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time <= 1)
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate+
+;
else
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate =
0;
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time =
curr_time;
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors++;
(opt_bf16_renonce == RENONCE_DISABLED))
UNINITIALIZED;
/* mark chip as FAILING if error rate too high*/

if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate >=
CHIP_ERROR_LIMIT) {
#ifdef FILELOG
filelog(info, "BF16: chip [%d:%d:%2d] error rate too high: [%d], "
"marked as failing, recovery_count: [%d]",
board_id, bcm250_id, chip_id,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count);
#endif
FAILING;
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate =
0;
}
}
static uint8_t* init_channel_path(uint8_t board_id, uint8_t btc250_num, uint8_t*

channel_depth, uint8_t channel_length)
{
uint8_t i, j;
uint8_t* channel_path = cgcalloc(channel_length, sizeof(uint8_t));
for (i = 0, j = 0; i < CHANNEL_DEPTH; i++) {

if (bcm250_map[board_id][btc250_num].channel_path[i] != BF250_NONE)
(*channel_depth)++;
int8_t shift = 8*(j + 1) - 3*(i + 1);

if (shift < 0) {
channel_path[j] |= bcm250_map[board_id]
[btc250_num].channel_path[i] >> abs(shift);
channel_path[j + 1] |= bcm250_map[board_id]
[btc250_num].channel_path[i] << (8 - abs(shift));
j++;
} else
channel_path[j] |= bcm250_map[board_id]
[btc250_num].channel_path[i] << shift;
}
return channel_path;
}
static int8_t parse_chip_address(struct cgpu_info *bitfury, char* address,

bf_chip_address_t* chip_address)
{
>device_data);
int8_t board_id = 0;
int8_t bcm250_id = 0;
int8_t chip_id = 0;
char buff[16];
if (address == NULL)
return -1;
/* board_id */
char* start = strchr(address, '[');
char* end = strchr(address, ':');
if ((start == NULL) || (end == NULL))
return -1;
uint8_t len = end - start;
memset(buff, 0, sizeof(buff));
cg_memcpy(buff, start + 1, len);
board_id = atoi(buff);
/* bcm250_id */
start = end;
end = strchr(start + 1, ':');
if (end == NULL)
return -1;
len = end - start;
bcm250_id = atoi(buff);
/* chip_id */
start = end;
end = strchr(start + 1, ']');
if (end == NULL)
return -1;
len = end - start;
chip_id = atoi(buff);
if ((board_id < 0) || (board_id >= CHIPBOARD_NUM)) {

applog(LOG_ERR, "%s: invalid board_id %d: [0 - %d] specified",
bitfury->drv->name,
board_id, CHIPBOARD_NUM);
return -1;
}
if ((bcm250_id < 0) || (bcm250_id >= BCM250_NUM)) {

applog(LOG_ERR, "%s: invalid bcm250_id %d: [0 - %d] specified",
bitfury->drv->name,
bcm250_id, BCM250_NUM);
return -1;
}
uint8_t first_good_chip = info-

>chipboard[board_id].bcm250[bcm250_id].last_good_chip;
if ((chip_id >= first_good_chip) && (chip_id < last_good_chip)) {

chip_address->board_id = board_id;
chip_address->bcm250_id = bcm250_id;
chip_address->chip_id = chip_id;
} else {
applog(LOG_ERR, "%s: invalid chip_id %d: [%d - %d] specified",
bitfury->drv->name,
chip_id, first_good_chip, last_good_chip);
return -1;
}
applog(LOG_NOTICE, "%s: parsed chip address: [%d:%d:%2d]",

bitfury->drv->name,
chip_address->board_id,
chip_address->bcm250_id,
chip_address->chip_id);
return 0;
}
static void update_bcm250_map(struct cgpu_info *bitfury, uint8_t board_id)
{
>device_data);
#ifdef MINER_X5
info->chipboard[board_id].board_type = CHIPBOARD_X5;
switch (info->chipboard[board_id].board_ver) {
/* 23 chip board version */
case 5:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][0].last_good_chip = BF16_NUM - 2;
bcm250_map[board_id][0].chips_num = BF16_NUM - 2;
bcm250_map[board_id][1].first_good_chip = 6;
bcm250_map[board_id][1].chips_num = 5;
break;

case 7:
break;

case 9:
break;

case 11:
break;

case 13:
break;
/* 26 chip board version - default */

case 1:
case 2:
default:
break;
}
#endif
#ifdef MINER_X6
info->chipboard[board_id].board_type = CHIPBOARD_X6;
switch (info->chipboard[board_id].board_ver) {
case 4:
bcm250_map[board_id][2].last_good_chip = 5;
break;

case 6:
break;

case 8:
break;

case 10:
break;

case 12:
break;

case 14:;
uint8_t bcm250_channel_path[3][CHANNEL_DEPTH] = {
{ BF250_CHAN1, BF250_CHAN1, BF250_LOCAL, BF250_NONE },
{ BF250_CHAN1, BF250_CHAN1, BF250_CHAN1, BF250_LOCAL },
{ BF250_CHAN1, BF250_CHAN1, BF250_CHAN2, BF250_LOCAL },
};
bcm250_map[board_id][2].last_good_chip = BF16_NUM;
bcm250_map[board_id][2].chips_num = BF16_NUM;
cg_memcpy(bcm250_map[board_id][3].channel_path,
bcm250_channel_path[0], sizeof(bcm250_map[board_id][3].channel_path));
bcm250_map[board_id][5].last_good_chip = BF16_NUM;
bcm250_map[board_id][5].chips_num = BF16_NUM;
break;
/* 52 chip board version - default */

case 3:
default:
break;
}
#endif
}
static void reinit_x5(struct bitfury16_info *info, bool chip_reinit)

{
uint8_t board_id, bcm250_id, chip_id;
/* reinit board chips */

for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
for (chip_id = first_good_chip; chip_id < last_good_chip;

chip_id++) {
if (chip_reinit == true) {
info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status =
UNINITIALIZED;
info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time = time(NULL);
gettimeofday(&info-
gettimeofday(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].switch_time, NULL);
} else {
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count <
CHIP_ERROR_FAIL_LIMIT)
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = UNINITIALIZED;
}
info-
gettimeofday(&info-
gettimeofday(&info-
}
}
}
/* send reset to all boards */

spi_emit_reset(SPI_CHANNEL1);
}
static void init_x5(struct cgpu_info *bitfury)

{
>device_data);
info->chipboard = cgcalloc(CHIPBOARD_NUM, sizeof(bf_chipboard_t));
/* channel size in bytes */

info->channel_length = (CHANNEL_DEPTH * 3) / 8 + 1;
info->ialarm_count = 1;
info->work_list = workd_list_init();
info->stale_work_list = workd_list_init();
info->noncework_list = noncework_list_init();
if (opt_bf16_renonce != RENONCE_DISABLED) {
info->renoncework_list = renoncework_list_init();
info->renonce_id = 1;
info->renonce_list = renonce_list_init();
}

/* detect board */
char buff[256];
device_ctrl_txrx(board_id + 1, 0, F_BDET, buff);

parse_board_detect(bitfury, board_id, buff);
if (info->chipboard[board_id].detected == true) {
applog(LOG_NOTICE, "%s: BOARD%d detected", bitfury->drv->name,
board_id + 1);
info->chipboard[board_id].bcm250 = cgcalloc(BCM250_NUM,
sizeof(bf_bcm250_t));
cmd_buffer_init(&info->chipboard[board_id].cmd_buffer);
get_board_info(bitfury, board_id);
update_bcm250_map(bitfury, board_id);
info->chipboard_num++;
info->chipboard[board_id].bcm250_num = BCM250_NUM;
cg_memcpy(&info->chipboard[board_id].pid, &pid,
sizeof(bf_pid_t));
uint8_t chips_num = 0;
info->chipboard[board_id].bcm250[bcm250_id].channel_path
= init_channel_path(board_id, bcm250_id,
&info-
>chipboard[board_id].bcm250[bcm250_id].channel_depth, info->channel_length);
info->chipboard[board_id].bcm250[bcm250_id].first_good_chip
= bcm250_map[board_id][bcm250_id].first_good_chip;
info->chipboard[board_id].bcm250[bcm250_id].last_good_chip
= bcm250_map[board_id][bcm250_id].last_good_chip;
info->chipboard[board_id].bcm250[bcm250_id].chips_num
= bcm250_map[board_id][bcm250_id].chips_num;
chips_num += bcm250_map[board_id][bcm250_id].chips_num;


chip_id++) {
info-
UNINITIALIZED;
info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonce_list =
nonce_list_init();
gettimeofday(&info-
gettimeofday(&info-
}
}
info->chipboard[board_id].chips_num = chips_num;
info->chips_num += info->chipboard[board_id].chips_num;
} else
applog(LOG_NOTICE, "%s: BOARD%d not found", bitfury->drv->name,
board_id + 1);
applog(LOG_INFO, "%s: initialized board X5.%d", bitfury->drv->name,

board_id);
}
applog(LOG_INFO, "%s: initialized X5", bitfury->drv->name);

}
static void deinit_x5(struct cgpu_info *bitfury)

{
>device_data);
workd_list_deinit(info->work_list, bitfury);
workd_list_deinit(info->stale_work_list, bitfury);
noncework_list_deinit(info->noncework_list);
renoncework_list_deinit(info->renoncework_list);
info->renonce_id = 1;
renonce_list_deinit(info->renonce_list);
}

free(info->chipboard[board_id].bcm250[bcm250_id].channel_path);


chip_id++)
nonce_list_deinit(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonce_list);
}
free(info->chipboard[board_id].bcm250);
cmd_buffer_deinit(&info->chipboard[board_id].cmd_buffer);
}
free(info->chipboard);
}
static void bitfury16_set_clock(struct cgpu_info *bitfury)

{
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
/* send reset to all boards */

/* board loop */
applog(LOG_NOTICE, "%s: CHIPBOARD [%d]:", bitfury->drv->name,
board_id);
/* concentrator loop */
applog(LOG_NOTICE, "%s: BCM250 [%d]:", bitfury->drv->name,
bcm250_id);
spi_emit_reset(board_id + 1);
/* build channel */
create_channel(board_id + 1, info-
>chipboard[board_id].bcm250[bcm250_id].channel_path, info->channel_length);
uint8_t channel_depth = info-

>chipboard[board_id].bcm250[bcm250_id].channel_depth;
uint8_t result;
bool fail;
/* chips loop */
chip_id++) {
fail = false;
bf_chip_address_t chip_address = { board_id, bcm250_id,
chip_id };
result = send_toggle(board_id + 1, channel_depth,

chip_address);
if (result != 0)
fail = true;
result = set_clock(board_id + 1, channel_depth,

chip_address, bf16_chip_clock);
if ((result != 0) && (fail != true))
fail = true;
if (fail == false)
applog(LOG_NOTICE, "%s: CHIP [%2d]: OK", bitfury-
>drv->name, chip_id);
else
applog(LOG_NOTICE, "%s: CHIP [%2d]: FAIL", bitfury-
>drv->name, chip_id);
}
/* destroy channel */
destroy_channel(board_id + 1, info-
>chipboard[board_id].bcm250[bcm250_id].channel_depth);
}
}
deinit_x5(bitfury);
}
static void bitfury16_test_chip(struct cgpu_info *bitfury, bf_chip_address_t

chip_address)
{

/* send reset to board */

/* build channel */
create_channel(board_id + 1, info-
>chipboard[board_id].bcm250[bcm250_id].channel_path, info->channel_length);
uint8_t channel_depth = info-

>chipboard[board_id].bcm250[bcm250_id].channel_depth;
uint8_t result;
bool fail = false;
result = send_toggle(board_id + 1, channel_depth, chip_address);

if (result != 0)
fail = true;
result = set_clock(board_id + 1, channel_depth, chip_address,

bf16_chip_clock);
if ((result != 0) && (fail != true))
fail = true;
if (fail == false)
applog(LOG_NOTICE, "%s: CHIP [%2d]: OK", bitfury->drv->name, chip_id);
else
applog(LOG_NOTICE, "%s: CHIP [%2d]: FAIL", bitfury->drv->name,
chip_id);
/* destroy channel */
destroy_channel(board_id + 1, info-
>chipboard[board_id].bcm250[bcm250_id].channel_depth);
deinit_x5(bitfury);
}
static void bitfury16_identify(__maybe_unused struct cgpu_info *bitfury)

{
}
static void set_fan_speed(struct cgpu_info *bitfury)
{
uint8_t board_id;

if (opt_bf16_fan_speed == -1) {
if (device_uart_transfer(board_id + 1, "F") < 0)
quit(1, "%s: %s() failed to set BOARD%d fan speed",
bitfury->drv->name, __func__, board_id +
1);
applog(LOG_INFO, "%s: set BOARD%d fan speed to auto mode",

bitfury->drv->name, board_id + 1);
} else {
char uart_cmd[8];
sprintf(uart_cmd, "F:%d", opt_bf16_fan_speed);
if (device_uart_transfer(board_id + 1, uart_cmd) < 0)

quit(1, "%s: %s() failed to set BOARD%d fan speed",
1);
applog(LOG_INFO, "%s: set BOARD%d fan speed to [%d]",

bitfury->drv->name, board_id + 1,
opt_bf16_fan_speed);
}
}
}
}
static void bitfury16_detect(bool hotplug)

{
struct cgpu_info *bitfury = NULL;
struct bitfury16_info *info = NULL;
if (hotplug)
return;
bitfury = cgmalloc(sizeof(struct cgpu_info));

if (unlikely(!bitfury))
quit(1, "%s: %s() failed to malloc bitfury",
bitfury->drv->name, __func__);
bitfury->drv = &bitfury16_drv;
bitfury->deven = DEV_ENABLED;
bitfury->threads = 1;
info = cgmalloc(sizeof(struct bitfury16_info));

if (unlikely(!info))
quit(1, "%s: %s() failed to malloc info",
bitfury->device_data = info;
/* manual PID option */

#ifdef MINER_X5
manual_pid_enabled = opt_bf16_manual_pid_enabled;
#endif
#ifdef MINER_X6
manual_pid_enabled = !opt_bf16_manual_pid_disabled;
#endif
/* renonce chip address and renonce chip clock */

if (opt_bf16_renonce_clock != NULL)
bf16_renonce_chip_clock = strtol(opt_bf16_renonce_clock, NULL,
16);
} else
/* default chip clock if renonce is disabled */
bf16_chip_clock = 0x2d;
/* general chip clock */

if (opt_bf16_clock != NULL)
bf16_chip_clock = strtol(opt_bf16_clock, NULL, 16);
else if ((opt_bf16_set_clock == true) || (opt_bf16_test_chip != NULL))
/* default chip clock if set_clock option is set */
bf16_chip_clock = 0x20;
/* open devices */
if (open_spi_device(SPI_CHANNEL1) < 0)
quit(1, "%s: %s() failed to open [%s] device",
bitfury->drv->name, __func__, spi0_device_name);
applog(LOG_INFO, "%s: opened [%s] device", bitfury->drv->name,

spi0_device_name);
if (open_spi_device(SPI_CHANNEL2) < 0)
bitfury->drv->name, __func__, spi1_device_name);

spi1_device_name);
if (open_ctrl_device() < 0)
bitfury->drv->name, __func__, ctrl_device_name);

ctrl_device_name);
if (open_uart_device(UART_CHANNEL1) < 0)
bitfury->drv->name, __func__, uart1_device_name);

uart1_device_name);
if (open_uart_device(UART_CHANNEL2) < 0)
bitfury->drv->name, __func__, uart2_device_name);

uart2_device_name);
init_x5(bitfury);
/* send reset to boards */

device_ctrl_transfer(board_id + 1, 1, F_BRST);
cgsleep_us(POWER_WAIT_INTERVAL);
device_ctrl_transfer(board_id + 1, 0, F_BRST);
applog(LOG_INFO, "%s: sent reset to BOARD%d",

}
}
/* check if board power is present */

/* read hw sensor data */
char buff[256];
if (device_uart_txrx(board_id + 1, "S", buff) < 0)
quit(1, "%s: %s() failed to get BOARD%d status",
bitfury->drv->name, __func__, board_id + 1);
if (parse_hwstats(info, board_id, buff) < 0)

applog(LOG_ERR, "%s: failed to parse hw stats",
/* disable board if power voltage is incorrect */

if ((info->chipboard[board_id].u_board < 10.0) ||
(info->chipboard[board_id].u_board > 15.0)) {
/* chips loop */
for (chip_id = first_good_chip; chip_id <
last_good_chip; chip_id++)
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = DISABLED;
}
applog(LOG_ERR, "%s: incorrect U board detected [%.1f] on

BOARD%d, "
"disabling board...",
bitfury->drv->name,
info->chipboard[board_id].u_board,
board_id + 1);
} else {
info->chipboard[board_id].active = true;
info->active_chipboard_num++;
}
}
}
/* enable power chain */

if (enable_power_chain(bitfury, board_id, 0) < 0)
info->chipboard[board_id].detected = false;
else {
#ifdef MINER_X5
info->chipboard[board_id].power_enable_time = time(NULL);
info->chipboard[board_id].power_disable_count = 1;
#endif
#ifdef MINER_X6
info->chipboard[board_id].power1_enable_time = time(NULL);
info->chipboard[board_id].power2_enable_time = time(NULL);
info->chipboard[board_id].power1_disable_count = 1;
info->chipboard[board_id].power2_disable_count = 1;
#endif
}
}
/* wait for power chain to enable */

if (opt_bf16_set_clock == true) {
applog(LOG_INFO, "%s: setting clock [%02x] to all chips",
bitfury->drv->name, bf16_chip_clock);
bitfury16_set_clock(bitfury);
quit(0, "Done.");
}
if (opt_bf16_test_chip != NULL) {
bf_chip_address_t chip_address = { 0, 0, 0 };
if (parse_chip_address(bitfury, opt_bf16_test_chip, &chip_address) < 0)

{
quit(1, "%s: %s() error parsing chip address...",
}
applog(LOG_INFO, "%s: testing communicaton with chip [%d:%d:%2d]",

bitfury->drv->name,
chip_address.board_id,
chip_address.bcm250_id,
chip_address.chip_id);
bitfury16_test_chip(bitfury, chip_address);
quit(0, "Done.");
}
/* fan speed */
if ((opt_bf16_fan_speed != -1) &&
(manual_pid_enabled == true)) {
manual_pid_enabled = false;
}
set_fan_speed(bitfury);

/* target temp */
if (opt_bf16_target_temp == -1) {
if (device_uart_transfer(board_id + 1, "T") < 0)
quit(1, "%s: %s() failed to set BOARD%d target temp",
1);
applog(LOG_INFO, "%s: set BOARD%d target temp to default

value",
} else {
char uart_cmd[8];
sprintf(uart_cmd, "T:%d", opt_bf16_target_temp);

quit(1, "%s: %s() failed to set BOARD%d target temp",
1);
applog(LOG_INFO, "%s: set BOARD%d target temp to [%d]",

opt_bf16_target_temp);
}
/* alarm temp */
if (opt_bf16_alarm_temp == -1) {
if (device_uart_transfer(board_id + 1, "C") < 0)
quit(1, "%s: %s() failed to set BOARD%d alarm temp",
1);
applog(LOG_INFO, "%s: set BOARD%d alarm temp to default

value",
} else {
char uart_cmd[8];
sprintf(uart_cmd, "C:%d", opt_bf16_alarm_temp);

quit(1, "%s: %s() failed to set BOARD%d alarm temp",
1);
applog(LOG_INFO, "%s: set BOARD%d alarm temp to [%d]",

opt_bf16_alarm_temp);
}
}
}
/* count number of renonce chips */

info->renonce_chips = opt_bf16_renonce;
uint8_t renonce_chips = 0;
if ((info->chipboard[board_id].detected == true) &&
(info->chipboard[board_id].active == true)) {
if (opt_bf16_renonce == RENONCE_ONE_CHIP) {
if (renonce_chips != info->renonce_chips)
renonce_chips++;
else {
renonce_chip_address[board_id].board_id = -1;
renonce_chip_address[board_id].bcm250_id = -1;
renonce_chip_address[board_id].chip_id = -1;
}
} else
renonce_chips++;
} else {
}
}
if (renonce_chips != info->renonce_chips) {
applog(LOG_ERR, "%s: expected to find [%d] renonce chips, but
found only [%d]",
bitfury->drv->name, opt_bf16_renonce, renonce_chips);
info->renonce_chips = renonce_chips;
}
} else {
}
}
/* correct renonce chip address */

if ((info->chipboard[board_id].detected == true) &&
(info->chipboard[board_id].active == true) &&
(renonce_chip_address[board_id].board_id != -1)) {
bcm250_id = renonce_chip_address[board_id].bcm250_id;

if (renonce_chip_address[board_id].chip_id >=
last_good_chip)
renonce_chip_address[board_id].chip_id =
last_good_chip - 1;
else if (renonce_chip_address[board_id].chip_id <
first_good_chip)
renonce_chip_address[board_id].chip_id =
first_good_chip;
}
}
}
#ifdef FILELOG
info->logfile = fopen(LOGFILE, "a");
if (info->logfile == NULL)
applog(LOG_ERR, "%s: failed to open logfile [%s]: %s",
bitfury->drv->name, LOGFILE, strerror(errno));
else
mutex_init(&info->logfile_mutex);
#endif
/* exit if no boards present */

if ((info->chipboard_num == 0) ||
(info->active_chipboard_num == 0)) {
deinit_x5(bitfury);
/* close devices */
close_spi_device(SPI_CHANNEL1);
close_ctrl_device();
close_uart_device(UART_CHANNEL1);
#ifdef FILELOG
fclose(info->logfile);
#endif
applog(LOG_ERR, "%s: no boards present. exiting...",

free(info);
free(bitfury);
return;
}
mutex_init(&info->nonces_good_lock);
if (!add_cgpu(bitfury))
quit(1, "%s: %s() failed to add_cgpu",
info->initialised = true;
applog(LOG_INFO, "%s: chip driver initialized", bitfury->drv->name);

#ifdef FILELOG
filelog(info, "%s: cgminer started", bitfury->drv->name);
#endif
}
static uint8_t chip_task_update(struct cgpu_info *bitfury, bf_chip_address_t

chip_address)
{
uint8_t i;
int8_t ret = 0;
bf_works_t work;
time_t curr_time_t;
struct timeval curr_time;

>device_data);
bf_cmd_buffer_t* cmd_buffer = &info->chipboard[board_id].cmd_buffer;
if (cmd_buffer->status != EMPTY)
return -1;
switch (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status) {
/* fill chip buffer with toggle task */

case UNINITIALIZED:
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], prepare
toggle_cmd",
bitfury->drv->name,
uint8_t toggle[4] = { 0xa5, 0x00, 0x00, 0x02 };
ret = cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth,
chip_address, chip_address,
work, 0, CHIP_CMD_TOGGLE, 3, toggle);
if (ret < 0)
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d], error
prepare toggle_cmd",
bitfury->drv->name,
break;
/* fill chip buffer with set clock task */

case TOGGLE_SET:
set_clock_cmd",
bitfury->drv->name,
uint8_t clock_buf[4];
memset(clock_buf, 0, sizeof(clock_buf));
/* init renonce chip with lower clock */

if ((renonce_chip(chip_address) == 1) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
gen_clock_data(bf16_renonce_chip_clock, 1, clock_buf);
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].clock
= bf16_renonce_chip_clock;
} else {
gen_clock_data(bf16_chip_clock, 1, clock_buf);
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].clock
= bf16_chip_clock;
}
work, 0, CHIP_CMD_SET_CLOCK, 3, clock_buf);
if (ret < 0)
prepare set_clock_cmd",
bitfury->drv->name,
break;
/* fill chip buffer with chip mask */

case CLOCK_SET:
set_mask_cmd",
bitfury->drv->name,
uint8_t noncemask[4];
memset(noncemask, 0, sizeof(noncemask));
for (i = 0; i < 4; i++)

noncemask[i] = (mask >> (8*(4 - i - 1))) & 0xff;
work, 0, CHIP_CMD_SET_MASK, 3, noncemask);
if (ret < 0)
prepare set_mask_cmd",
bitfury->drv->name,
break;
/* fill chip buffer with new task */

case MASK_SET:
send_task_cmd",
bitfury->drv->name,
L_LOCK(info->work_list);
L_LOCK(info->stale_work_list);
if (info->work_list->count > 0) {
memset(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.task, 0,
sizeof(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.task));
bf_data_t* wdata = info->work_list->head;
workd_list_push(info->stale_work_list, WORKD(wdata));
workd_list_remove(info->work_list, &info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork);
gen_task_data(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.payload.midstate,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.payload.m7,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.payload.ntime,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.payload.nbits, mask,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.task);
info-
>chipboard[board_id].bcm250[bcm250_id].channel_depth, chip_address, chip_address,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork, 0,
CHIP_CMD_TASK_WRITE, 79,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork.task);
if (ret < 0)
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:
%2d], error prepare send_task_cmd",
bitfury->drv->name,
}
#if 0
else
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d],
error prepare send_task_cmd: no works available",
bitfury->drv->name,
#endif
L_UNLOCK(info->stale_work_list);
L_UNLOCK(info->work_list);
}
break;
/* fill chip buffer with check status task */

case TASK_SENT:
gettimeofday(&curr_time, NULL);
if (((renonce_chip(chip_address) == 0) ||
(opt_bf16_renonce == RENONCE_DISABLED)) &&
(timediff_us(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time, curr_time) >
CHIP_TASK_STATUS_INTERVAL)) {
task_status_cmd",
bitfury->drv->name,
info-
work, 0, CHIP_CMD_TASK_STATUS, 0, NULL);
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time.tv_sec =
curr_time.tv_sec;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time.tv_usec =
curr_time.tv_usec;
if (ret < 0)
error prepare task_status_cmd",
bitfury->drv->name,
}
break;
/* fill chip buffer with read nonces task */

case TASK_SWITCHED:
read_nonce_cmd",
bitfury->drv->name,
info-
work, 0, CHIP_CMD_READ_NONCE, 0, NULL);
if (ret < 0)
error prepare read_nonce_cmd",
bitfury->drv->name,
}
break;
/* mark chip as UNINITIALIZED and start all over again */

case FAILING:
curr_time_t = time(NULL);
time_t time_diff = curr_time_t - info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time;
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count <
CHIP_ERROR_FAIL_LIMIT) {
if (time_diff >= info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count *
CHIP_RECOVERY_INTERVAL) {
/* change renonce chip address if

RENONCE_CHIP_ERROR_FAIL_LIMIT reached */
if ((renonce_chip(chip_address) == 1) &&
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count ==
RENONCE_CHIP_ERROR_FAIL_LIMIT) {
applog(LOG_ERR, "%s: chipworker_thr: renonce
chip [%d:%d:%2d] failed. trying to switch to another one...",
bitfury->drv->name,
chip_address.board_id,
chip_address.bcm250_id,
chip_address.chip_id);
if (change_renonce_chip_address(bitfury,
chip_address) == 0) {
info-
UNINITIALIZED;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time =
curr_time_t;
gettimeofday(&info-
}
} else {
info-
UNINITIALIZED;
info-
curr_time_t;
gettimeofday(&info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count++;
}
} else {
info-
UNINITIALIZED;
info-
curr_time_t;
gettimeofday(&info-
gettimeofday(&info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count++;
#ifdef FILELOG
filelog(info, "BF16: chip [%d:%d:%2d] recovered
time_diff: [%d], "
"recovery_count: [%d], error_rate: [%d]",
time_diff,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate);
#endif
}
}
}
/* mark chip as DISABLED and never communicate to it again */
else if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status != DISABLED) {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status
= DISABLED;
#ifdef FILELOG
filelog(info, "BF16: disabling chip [%d:%d:%2d] recovery_count:
[%d], error_rate: [%d]",
info-
info-
#endif
}
break;
case DISABLED:
default:
break;
}
return ret;
}
static uint8_t renonce_task_update_loop(struct cgpu_info *bitfury, uint8_t

board_id,
bf_renonce_stage_t stage, uint8_t renonce_count)
{
>device_data);
uint8_t bcm250_id = renonce_chip_address[board_id].bcm250_id;

uint8_t chip_id = renonce_chip_address[board_id].chip_id;
uint8_t nonces = 0;
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status <
FAILING) {
L_LOCK(info->renonce_list);
bf_data_t* rdata = info->renonce_list->head;
while ((rdata != NULL) && (nonces < renonce_count)) {
uint8_t ret = 1;
if ((RENONCE(rdata)->sent == false) &&

(RENONCE(rdata)->stage == stage)) {
/* generate work mask */
uint32_t nonce_mask = gen_mask(RENONCE(rdata)->nonce,
mask_bits);
nonce_mask = ntohl(nonce_mask);
switch (RENONCE(rdata)->stage) {
case RENONCE_STAGE0:
/* generate chip work with new mask */
cg_memcpy(RENONCE(rdata)->owork.task + 19*4,
&nonce_mask, sizeof(nonce_mask));
/* send task and read nonces at the same time

*/
info-
>chipboard[board_id].bcm250[bcm250_id].channel_depth,
renonce_chip_address[board_id],
RENONCE(rdata)->src_address,
RENONCE(rdata)->owork,
RENONCE(rdata)->id,
(CHIP_CMD_TASK_WRITE |
CHIP_CMD_TASK_SWITCH | CHIP_CMD_READ_NONCE), 79,
RENONCE(rdata)->owork.task);
break;
/* generate chip work with new mask */
cg_memcpy(RENONCE(rdata)->cwork.task + 19*4,
&nonce_mask, sizeof(nonce_mask));
/* send task and read nonces at the same time

*/
info-
>chipboard[board_id].bcm250[bcm250_id].channel_depth,
RENONCE(rdata)->src_address,
RENONCE(rdata)->cwork,
RENONCE(rdata)->id,
(CHIP_CMD_TASK_WRITE |
CHIP_CMD_TASK_SWITCH | CHIP_CMD_READ_NONCE), 79,
RENONCE(rdata)->cwork.task);
break;
case RENONCE_STAGE_FINISHED:
default:
break;
}
}
if (ret == 0) {
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = TASK_SWITCHED;
RENONCE(rdata)->sent = true;
RENONCE(rdata)->received = false;
nonces++;
}
rdata = rdata->next;
}
L_UNLOCK(info->renonce_list);
}
return nonces;
}
static void renonce_task_update(struct cgpu_info *bitfury, uint8_t board_id,

uint8_t renonce_count)
{
>device_data);
bf_works_t work;
uint8_t i;

cmd_buffer_push_create_channel(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_path,
info->channel_length);
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status <
FAILING) {
uint8_t toggle[4] = { 0xa5, 0x00, 0x00, 0x02 };
cmd_buffer_push(cmd_buffer,
work, 0, CHIP_CMD_TOGGLE, 3, toggle);
uint8_t clock_buf[4];
memset(clock_buf, 0, sizeof(clock_buf));
gen_clock_data(bf16_renonce_chip_clock, 1, clock_buf);
work, 0, CHIP_CMD_SET_CLOCK, 3, clock_buf);
uint8_t noncemask[4];
memset(noncemask, 0, sizeof(noncemask));
for (i = 0; i < 4; i++)

noncemask[i] = (mask >> (8*(4 - i - 1))) & 0xff;
work, 0, CHIP_CMD_SET_MASK, 3, noncemask);
bf_renonce_stage_t stage = RENONCE_STAGE0;

while ((renonce_count > 0) && (stage != RENONCE_STAGE_FINISHED)) {
renonce_count -= renonce_task_update_loop(bitfury, board_id,
stage++, renonce_count);
}
}
cmd_buffer_push_destroy_channel(cmd_buffer,
info->chipboard[board_id].
bcm250[renonce_chip_address[board_id].bcm250_id].channel_depth);
}
static void fill_cmd_buffer_loop(struct cgpu_info *bitfury, uint8_t board_id, bool

do_renonce, uint16_t renonce_count)
{
uint8_t bcm250_id, chip_id;
>device_data);
cmd_buffer_push_create_channel(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_path,
info->channel_length);
/* chips loop */
for (chip_id = first_good_chip; chip_id < last_good_chip; chip_id++) {
bf_chip_address_t chip_address = { board_id, bcm250_id,
chip_id };
chip_task_update(bitfury, chip_address);
}
cmd_buffer_push_destroy_channel(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth);
}
if (do_renonce == true) {
uint8_t count = (cmd_buffer->free_bytes - (2 + 11 + 11 + 11 + 8)) /
136;
if (count < renonce_count) {
if (count > 0)
renonce_task_update(bitfury, board_id, count);
} else if (renonce_count > 0)
renonce_task_update(bitfury, board_id, renonce_count);
}
cmd_buffer->status = TX_READY;
}
static void fill_cmd_buffer(struct cgpu_info *bitfury, uint8_t board_id)

{
static uint8_t do_renonce[CHIPBOARD_NUM];
uint16_t renonce_count = 0;

>device_data);
if (cmd_buffer->status == EMPTY) {
if ((opt_bf16_renonce == RENONCE_DISABLED) ||
(renonce_chip_address[board_id].board_id == -1)) {
fill_cmd_buffer_loop(bitfury, board_id, false, 0);

} else {
while (rdata != NULL) {
if (RENONCE(rdata)->sent == false)
renonce_count++;
}
if (do_renonce[board_id] < RENONCE_SEND) {

fill_cmd_buffer_loop(bitfury, board_id, true,
renonce_count);
do_renonce[board_id]++;
} else {
if (renonce_count >= RENONCE_COUNT) {
renonce_task_update(bitfury, board_id,
RENONCE_COUNT);
do_renonce[board_id] = 0;
cmd_buffer->status = TX_READY;
} else {
fill_cmd_buffer_loop(bitfury, board_id, true,
renonce_count);
do_renonce[board_id]++;
}
}
}
}
}
static uint8_t update_chip_status(struct cgpu_info *bitfury, bf_cmd_status_t

cmd_status)
{
>device_data);
uint8_t board_id = cmd_status.chip_address.board_id;
uint8_t bcm250_id = cmd_status.chip_address.bcm250_id;
uint8_t chip_id = cmd_status.chip_address.chip_id;
switch (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status) {
case UNINITIALIZED:
case TOGGLE_SET:
case CLOCK_SET:
case MASK_SET:
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], send_cmd
[%s]",
bitfury->drv->name,
get_cmd_description(cmd_status.cmd_code));
/* update chip status */

if (cmd_status.checksum_error == false)
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status++;
else {
#ifndef DISABLE_SEND_CMD_ERROR
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d]: error
send_cmd [%s]. "
"checksum: expected: [%02x]; received: [%02x]",
bitfury->drv->name,
get_cmd_description(cmd_status.cmd_code),
cmd_status.checksum_expected,
cmd_status.checksum_received);
#endif
/* increase error counters */

increase_errors(info, cmd_status.chip_address);
}
break;
case TASK_SENT:
[%s]",
bitfury->drv->name,
/* read task status from chip*/

if (cmd_status.checksum_error == false) {
uint8_t new_buff = ((cmd_status.status & 0x0f) == 0x0f) ? 1 : 0;
/* status cmd counter */

info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_dx++;
info->chipboard[board_id].bcm250[bcm250_id].status_cmd_dx++;
info->chipboard[board_id].status_cmd_dx++;
info->status_cmd_dx++;
/* check if chip task has switched */

if (new_buff != info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].curr_buff) {
gettimeofday(&info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].curr_buff = new_buff;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status++;
/* task switch counter */

increase_task_switch(info, cmd_status.chip_address);
} else {
/* task not switched */
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_none_dx++;
info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd_none_dx++;
info->chipboard[board_id].status_cmd_none_dx++;
info->status_cmd_none_dx++;
/* check if chip hang */

if ((timediff_us(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].switch_time, curr_time) >
CHIP_TASK_SWITCH_INTERVAL) &&
(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING)) {
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = FAILING;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time = time(NULL);
applog(LOG_ERR, "%s: nonceworker_thr: chip [%d:%d:

%2d], "
"failed: no task switch during last
[%.3f] seconds",
bitfury->drv->name,
CHIP_TASK_SWITCH_INTERVAL / 1000000.0);
#ifdef FILELOG
filelog(info, "BF16: no task switch for chip [%d:%d:
%2d], "
"error count: [%d], recovery_count: [%d],
error_rate: [%d]",
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
info-
info-
#endif
}
}
} else {
send_cmd [%s]. "
bitfury->drv->name,
#endif

}
break;
case TASK_SWITCHED:
[%s]",
bitfury->drv->name,
if (cmd_status.checksum_error == false) {
if ((renonce_chip(cmd_status.chip_address) == 1) &&
/* task switch counter */

if (cmd_status.cmd_code & CHIP_CMD_READ_NONCE)
increase_task_switch(info, cmd_status.chip_address);
} else if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING) {
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_processed++;
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_processed >=
CHIP_RESTART_LIMIT) {
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = UNINITIALIZED;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_processed = 0;
} else
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = MASK_SET;
}
return 1;
} else {
send_cmd [%s]. "
bitfury->drv->name,
#endif

}
break;
case FAILING:
case DISABLED:
default:
break;
}
return 0;
}
static uint8_t process_nonces(struct cgpu_info *bitfury, bf_cmd_status_t

cmd_status, uint32_t* nonces)
{
>device_data);
uint8_t i;
uint32_t found_nonces[12];
uint8_t board_id = cmd_status.chip_address.board_id;

uint8_t bcm250_id = cmd_status.chip_address.bcm250_id;
uint8_t chip_id = cmd_status.chip_address.chip_id;
if ((cmd_status.checksum_error == false) &&
(cmd_status.nonce_checksum_error == false)) {
cg_memcpy(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].rx, nonces,
sizeof(found_nonces));
uint8_t found = find_nonces(info-

>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].rx,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].rx_prev,
found_nonces);
/* check if chip is still mining */

if (found == 0) {
time_t time_diff = curr_time - info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time;
if ((time_diff >= RENONCE_CHIP_FAILING_INTERVAL) &&
(info-
info-
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time = curr_time;
applog(LOG_ERR, "%s: nonceworker_thr: renonce chip

[%d:%d:%2d] "
"failed: no good nonces during last
[%.1f] seconds",
bitfury->drv->name,
RENONCE_CHIP_FAILING_INTERVAL);
#ifdef FILELOG
filelog(info, "BF16: no good nonces from renonce chip
[%d:%d:%2d], "
"error count: [%d] recovery_count: [%d],
error_rate: [%d]",
info-
info-
info-
#endif
}
} else {
if ((time_diff >= CHIP_FAILING_INTERVAL) &&
(info-
info-
info-

%2d], "
[%.1f] seconds",
bitfury->drv->name,
CHIP_FAILING_INTERVAL);
#ifdef FILELOG
filelog(info, "BF16: no good nonces from chip [%d:%d:
%2d], "
error_rate: [%d]",
info-
info-
info-
#endif
}
}
}
/* increase stage if no nonces received */

if (RENONCE(rdata)->id == cmd_status.id) {
if (found == 0) {
RENONCE(rdata)->stage++;
RENONCE(rdata)->sent = false;
/* clear renonces list if we are running too

slow */
if ((RENONCE(rdata)->stage >= RENONCE_STAGE2)
&&
(info->renonce_list->count >
RENONCE_STAGE2_LIMIT)) {
info->unmatched++;
increase_re_bad_nonces(info,
RENONCE(rdata)->src_address);
bf_data_t* rndata = rdata->next;
renonce_list_remove(info->renonce_list,
rdata);
rdata = rndata;
continue;
}
if ((RENONCE(rdata)->stage >= RENONCE_STAGE3)

&&
(info->renonce_list->count >
RENONCE_STAGE3_LIMIT)) {
info->unmatched++;
rdata);
rdata = rndata;
continue;
}
/* remove expired renonce */

if (RENONCE(rdata)->stage ==
RENONCE_STAGE_FINISHED) {
info->unmatched++;
rdata);
rdata = rndata;
continue;
}
}
RENONCE(rdata)->received = true;
break;
}
}
}
bf_list_t* nonce_list = info-

>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonce_list;
for (i = 0; i < found; i++) {
L_LOCK(nonce_list);
int8_t res = nonce_list_push(nonce_list, found_nonces[i]);
L_UNLOCK(nonce_list);
if (res < 0)
continue;
increase_total_nonces(info, cmd_status.chip_address);
/* check if nonce has errors and add it to renonce list */

if ((opt_bf16_renonce != RENONCE_DISABLED) &&
(renonce_chip(cmd_status.chip_address) == 0) &&
(found_nonces[i] & 0xfff00000) == 0xaaa00000) {
increase_re_nonces(info, cmd_status.src_address);
if (info->renonce_list->count < RENONCE_QUEUE_LEN) {
renonce_list_push(info->renonce_list,
info->renonce_id++,
found_nonces[i],
cmd_status.chip_address,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].owork);
} else
cmd_status.chip_address);
applog(LOG_DEBUG, "%s: chipworker_thr: pushing renonce

task: nonce: [%08x]",
bitfury->drv->name,
found_nonces[i]);
continue;
}
/* add nonces to noncework list */

L_LOCK(info->renoncework_list);
renoncework_list_push(info->renoncework_list,
cmd_status.chip_address, found_nonces[i]);
L_UNLOCK(info->renoncework_list);
} else {
L_LOCK(info->noncework_list);
noncework_list_push(info->noncework_list,
cmd_status.chip_address,
cmd_status.src_address,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork,
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].owork,
found_nonces[i]);
L_UNLOCK(info->noncework_list);
}
applog(LOG_DEBUG, "%s: chipworker_thr: pushing nonce task: nonce:

[%08x]",
bitfury->drv->name,
found_nonces[i]);
}
/* rotate works and buffers */

cg_memcpy(info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].rx_prev,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].rx,
sizeof(found_nonces));
cg_memcpy(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].owork,
&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].cwork, sizeof(bf_works_t));
/* remove old nonces from nonce list */

L_LOCK(nonce_list);
while (nonce_list->count > RENONCE_CHIP_QUEUE_LEN)
nonce_list_pop(nonce_list);
} else {
while (nonce_list->count > NONCE_CHIP_QUEUE_LEN)
nonce_list_pop(nonce_list);
}
L_UNLOCK(nonce_list);
} else {
if (cmd_status.checksum_error != 0) {
send_cmd [%s]. "
bitfury->drv->name,
#endif

}
if (cmd_status.nonce_checksum_error != 0) {
if ((renonce_chip(cmd_status.chip_address) == 0) ||
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d]:
error receiving data. "
"nonce checksum: expected: [%02x]; received:
[%02x]",
bitfury->drv->name,

}
}
}
return 0;
}
/* routine sending-receiving data to chipboard */

static void process_cmd_buffer(struct cgpu_info *bitfury, uint8_t board_id)
{
>device_data);
uint8_t i;
bf_cmd_status_t cmd_status;
if (cmd_buffer->status == EXECUTED) {
/* process extracted data */
uint16_t cmd_number = cmd_buffer->cmd_list->count;
for (i = 0; i < cmd_number; i++) {
uint32_t nonces[12];
cmd_buffer_pop(cmd_buffer, &cmd_status, nonces);

if ((cmd_status.cmd_code == CHIP_CMD_CREATE_CHANNEL) ||
(cmd_status.cmd_code == CHIP_CMD_TASK_SWITCH))
continue;
uint8_t task_switch = update_chip_status(bitfury, cmd_status);
/* analyze nonces */
if ((cmd_status.cmd_code & CHIP_CMD_READ_NONCE) &&
(task_switch == 1)) {
process_nonces(bitfury, cmd_status, nonces);
}
}
cmd_buffer_clear(cmd_buffer);
}
}
static void *bitfury_chipworker(void *userdata)

{
struct cgpu_info *bitfury = (struct cgpu_info *)userdata;
>device_data);
uint8_t board_id;
applog(LOG_INFO, "%s: started chipworker thread", bitfury->drv->name);
while (bitfury->shutdown == false) {

if (info->initialised) {
break;
}
cgsleep_us(30);
}
/* send reset sequence to boards */


if ((info->a_temp == false) &&
(info->a_ichain == false)) {
/* prepare send buffer */
struct timeval start_time, stop_time;
gettimeofday(&start_time, NULL);
if (info->chipboard[board_id].cmd_buffer.status ==
EMPTY)
fill_cmd_buffer(bitfury, board_id);
gettimeofday(&stop_time, NULL);
#if 0
applog(LOG_ERR, "%s: chipworker_thr: board %d buffer
prepare: time elapsed: [%.6f]",
bitfury->drv->name, board_id,
timediff(start_time, stop_time));
#endif
/* send buffer to chipboard */
TX_READY) {
cmd_buffer_exec(board_id + 1, &info-
>chipboard[board_id].cmd_buffer);
info->chipboard[board_id].bytes_transmitted_dx
+= info->chipboard[board_id].cmd_buffer.tx_offset;
info->chipboard[board_id].bytes_transmitted
+= info->chipboard[board_id].cmd_buffer.tx_offset;
}
#if 0
applog(LOG_ERR, "%s: chipworker_thr: board %d TX/RX
time: [%.6f]",
#endif
/* analyze received data */

EXECUTED) {
process_cmd_buffer(bitfury, board_id);
}
#if 0
applog(LOG_ERR, "%s: chipworker_thr: board %d buffer
processing: time elapsed: [%.6f]",
#endif
}
}
} else
cgsleep_us(CHIPWORKER_DELAY);
}
applog(LOG_INFO, "%s: chipworker_thr: exiting...", bitfury->drv->name);

return NULL;
}
static int16_t cleanup_older(struct cgpu_info *bitfury)

{
>device_data);
uint16_t released = 0;
/* clear stale work list */

bf_data_t* wdata = info->stale_work_list->head;
while (wdata != NULL) {
if (curr_time - WORKD(wdata)->generated >= WORK_TIMEOUT) {
workd_list_pop(info->stale_work_list, bitfury);
released++;
} else
break;
wdata = info->stale_work_list->head;
}
applog(LOG_INFO, "%s: released %d works", bitfury->drv->name, released);

return released;
}
static void *bitfury_nonceworker(void *userdata)

{
>device_data);
applog(LOG_INFO, "%s: started nonceworker thread", bitfury->drv->name);

break;
}
cgsleep_us(30);
}
applog(LOG_INFO, "%s: nonceworker loop started", bitfury->drv->name);

uint32_t nonce_cnt = 0;
/* general nonces processing */

bf_data_t* nwdata = info->noncework_list->head;
while (nwdata != NULL) {
uint8_t board_id = NONCEWORK(nwdata)->chip_address.board_id;
uint8_t bcm250_id = NONCEWORK(nwdata)->chip_address.bcm250_id;
uint8_t chip_id = NONCEWORK(nwdata)->chip_address.chip_id;
nonce_cnt++;
/* general chip results processing */

if (test_nonce(&NONCEWORK(nwdata)->owork.work, NONCEWORK(nwdata)-
>nonce)) {
applog(LOG_DEBUG, "%s: nonceworker_thr: chip [%d:%d:%2d],
valid nonce [%08x]",
bitfury->drv->name,
NONCEWORK(nwdata)->nonce);
submit_tested_work(info->thr, &NONCEWORK(nwdata)-
>owork.work);
info-
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count > 0) {
info-
#ifdef FILELOG
filelog(info, "BF16: good nonce for chip [%d:%d:%2d]
"
"setting recovery_count to [0],
error_rate: [%d]",
info-
#endif
}
increase_good_nonces(info, NONCEWORK(nwdata)-
>chip_address);
mutex_lock(&info->nonces_good_lock);
info->nonces_good_cg++;
mutex_unlock(&info->nonces_good_lock);
} else if (test_nonce(&NONCEWORK(nwdata)->cwork.work,
NONCEWORK(nwdata)->nonce)) {
applog(LOG_DEBUG, "%s: nonceworker_thr: chip [%d:%d:%2d],
valid nonce [%08x]",
bitfury->drv->name,
submit_tested_work(info->thr, &NONCEWORK(nwdata)-
>cwork.work);
info-
if (info-
info-
#ifdef FILELOG
filelog(info, "BF16: good nonce for chip [%d:%d:%2d]
"
"setting recovery_count to 0, error_rate:
[%d]",
info-
#endif
}
increase_good_nonces(info, NONCEWORK(nwdata)-
>chip_address);
} else {
if ((time_diff >= CHIP_FAILING_INTERVAL) &&

(info-
increase_errors(info, NONCEWORK(nwdata)-
>chip_address);
info-
info-

%2d], "
[%.1f] seconds",
bitfury->drv->name,
CHIP_FAILING_INTERVAL);
#ifdef FILELOG
filelog(info, "BF16: no good nonces from chip [%d:%d:
%2d], "
error_rate: [%d]",
info-
info-
info-
#endif
}
/* add failed nonce to renonce list */
increase_bad_nonces(info, NONCEWORK(nwdata)-
>chip_address);
if (info->renonce_list->count < RENONCE_QUEUE_LEN) {
renonce_list_push(info->renonce_list,
info->renonce_id++,
NONCEWORK(nwdata)->nonce,
NONCEWORK(nwdata)->chip_address,
NONCEWORK(nwdata)->cwork,
NONCEWORK(nwdata)->owork);
} else
increase_re_bad_nonces(info, NONCEWORK(nwdata)-
>chip_address);
applog(LOG_DEBUG, "%s: nonceworker_thr: pushing

renonce task: nonce: [%08x]",
bitfury->drv->name,
} else
increase_bad_nonces(info, NONCEWORK(nwdata)-
>chip_address);
}
/* remove nonce from list */

noncework_list_pop(info->noncework_list);
nwdata = info->noncework_list->head;
}
/* cleanup older works */

cleanup_older(bitfury);
#if 0
applog(LOG_DEBUG, "%s: nonceworker_thr: nonces processed [%d]: time
elapsed: [%.6f]",
bitfury->drv->name,
nonce_cnt, timediff(start_time, stop_time));
#endif
cgsleep_us(NONCEWORKER_DELAY);
}
applog(LOG_INFO, "%s: nonceworker_thr: exiting...", bitfury->drv->name);

return NULL;
}
static bool test_renonce(struct cgpu_info *bitfury, bf_data_t* rdata, bf_data_t*

rnwdata, bool owork)
{
>device_data);
uint8_t board_id = RENONCEWORK(rnwdata)->src_address.board_id;

if (owork == true) {
if (test_nonce(&RENONCE(rdata)->owork.work, RENONCEWORK(rnwdata)-
>nonce)) {
applog(LOG_DEBUG, "%s: renonceworker_thr: restored renonce:
nonce: [%08x]",
bitfury->drv->name,
RENONCEWORK(rnwdata)->nonce);
submit_tested_work(info->thr, &RENONCE(rdata)->owork.work);
info-
if (info-
info-
#ifdef FILELOG
filelog(info, "BF16: good nonce for renonce chip [%d:%d:
%2d] "
[%d]",
info-
#endif
}
increase_re_good_nonces(info, RENONCE(rdata)->src_address);
increase_re_good_nonces(info, renonce_chip_address[board_id]);
RENONCE(rdata)->match = true;
} else {

(info-
increase_errors(info, renonce_chip_address[board_id]);
info-
info-
applog(LOG_ERR, "%s: nonceworker_thr: renonce chip [%d:%d:

%2d] "
"failed: no good nonces during last [%.1f]
seconds",
bitfury->drv->name,
#ifdef FILELOG
filelog(info, "BF16: no good nonces from renonce chip [%d:
%d:%2d], "
error_rate: [%d]",
info-
info-
info-
#endif
}
}
} else {
if (test_nonce(&RENONCE(rdata)->cwork.work, RENONCEWORK(rnwdata)-
>nonce)) {
applog(LOG_DEBUG, "%s: renonceworker_thr: restored renonce:
nonce: [%08x]",
bitfury->drv->name,
RENONCEWORK(rnwdata)->nonce);
submit_tested_work(info->thr, &RENONCE(rdata)->cwork.work);
info-
if (info-
info-
#ifdef FILELOG
filelog(info, "BF16: good nonce for renonce chip [%d:%d:
%2d] "
[%d]",
info-
#endif
}
increase_re_good_nonces(info, RENONCE(rdata)->src_address);
increase_re_good_nonces(info, renonce_chip_address[board_id]);
RENONCE(rdata)->match = true;
} else {

(info-
increase_errors(info, renonce_chip_address[board_id]);
info-
info-
applog(LOG_ERR, "%s: nonceworker_thr: renonce chip [%d:%d:

%2d] "
"failed: no good nonces during last [%.1f]
seconds",
bitfury->drv->name,
#ifdef FILELOG
filelog(info, "BF16: no good nonces from renonce chip [%d:
%d:%2d], "
error_rate: [%d]",
info-
info-
info-
#endif
}
}
}
return RENONCE(rdata)->match;
}
static void *bitfury_renonceworker(void *userdata)

{
>device_data);
bf_list_t* id_list = nonce_list_init();
applog(LOG_INFO, "%s: started renonceworker thread", bitfury->drv->name);

break;
}
cgsleep_us(30);
}
applog(LOG_INFO, "%s: renonceworker loop started", bitfury->drv->name);

uint32_t nonce_cnt = 0;
/* renonce chip results processing */

bf_data_t* rnwdata = info->renoncework_list->head;
while (rnwdata != NULL) {
nonce_cnt++;
/* find nonce by id */
if (match_nonce(RENONCEWORK(rnwdata)->nonce,
RENONCE(rdata)->nonce, mask_bits)) {
if (RENONCE(rdata)->match == false) {
switch (RENONCE(rdata)->stage) {
if (test_renonce(bitfury, rdata,
rnwdata, true) == true)
info->stage0_match++;
else
info->stage0_mismatch++;
break;
/* test old work first */
if (test_renonce(bitfury, rdata,
rnwdata, true) == true) {
RENONCE_STAGE1)
RENONCE_STAGE2)
info->stage2_match++;
RENONCE_STAGE3)
} else {
if (test_renonce(bitfury,
rdata, rnwdata, false) == true) {
if (RENONCE(rdata)-
>stage == RENONCE_STAGE1)
info-
>stage1_match++;
if (RENONCE(rdata)-
info-
>stage2_mismatch++;
if (RENONCE(rdata)-
info-
>stage3_match++;
}
}
break;
default:
applog(LOG_ERR, "%s:
renonceworker_thr: invalid renonce stage arrived: [%d]",
bitfury->drv->name,
RENONCE(rdata)->stage);
}
}
nonce_list_push(id_list, RENONCE(rdata)->id);
if (RENONCE(rdata)->match == true)
break;
}
}
/* remove nonce from list */

renoncework_list_pop(info->renoncework_list);
rnwdata = info->renoncework_list->head;
}
if (RENONCE(rdata)->match == true) {
renonce_list_remove(info->renonce_list, rdata);
rdata = rndata;
continue;
}
/* update stage */
bf_data_t* ndata = id_list->head;
while (ndata != NULL) {
if (NONCE(ndata)->nonce == RENONCE(rdata)->id) {
break;
}
ndata = ndata->next;
}
/* update tasks with wrong or dup nonces recieved */

if ((RENONCE(rdata)->stage != RENONCE_STAGE_FINISHED) &&
(RENONCE(rdata)->received == true)) {
}
/* clear renonces list if we are running too slow */

if ((RENONCE(rdata)->stage >= RENONCE_STAGE2) &&
(info->renonce_list->count > RENONCE_STAGE2_LIMIT)) {
info->unmatched++;
increase_re_bad_nonces(info, RENONCE(rdata)->src_address);
rdata = rndata;
continue;
}
if ((RENONCE(rdata)->stage >= RENONCE_STAGE3) &&

(info->renonce_list->count > RENONCE_STAGE3_LIMIT)) {
info->unmatched++;
rdata = rndata;
continue;
}
if ((RENONCE(rdata)->stage == RENONCE_STAGE_FINISHED) &&
(RENONCE(rdata)->sent == false)) {
info->unmatched++;
rdata = rndata;
continue;
}
}
/* clear id list */
bf_data_t* ndata = id_list->head;
while (ndata != NULL) {
nonce_list_pop(id_list);
ndata = id_list->head;
}
#if 0
applog(LOG_DEBUG, "%s: renonceworker_thr: nonces processed [%d]: time
elapsed: [%.6f]",
bitfury->drv->name,
nonce_cnt, timediff(start_time, stop_time));
#endif
cgsleep_us(RENONCEWORKER_DELAY);
}
applog(LOG_INFO, "%s: renonceworker_thr: exiting...", bitfury->drv->name);

return NULL;
}
int16_t update_pid(bf_pid_t *pid, int16_t error)

{
int16_t pTerm, iTerm;
pTerm = 2 * error;
pid->i_state += error;
if(pid->i_state > pid->i_max)
pid->i_state = pid->i_max;
else if(pid->i_state < pid->i_min)
pid->i_state = pid->i_min;
iTerm = pid->i_state;
return (pTerm + iTerm);

}
static void *bitfury_hwmonitor(void *userdata)

{
>device_data);
time_t curr_time;
applog(LOG_INFO, "%s: started hwmonitor thread", bitfury->drv->name);

break;
}
cgsleep_us(30);
}
applog(LOG_INFO, "%s: hwmonitor loop started", bitfury->drv->name);

float max_temp = 0.0;
float t_alarm = 100.0;
bool a_temp = false;

bool a_ichain = false;
/* read hw sensor data */
char buff[256];
if (device_uart_txrx(board_id + 1, "S", buff) < 0)
quit(1, "%s: %s() failed to get BOARD%d status",
bitfury->drv->name, __func__, board_id + 1);
if (parse_hwstats(info, board_id, buff) < 0)

applog(LOG_ERR, "%s: failed to parse hw stats",
info->chipboard[board_id].p_chain1 = info-
>chipboard[board_id].u_chain1 * info->chipboard[board_id].i_chain1;
info->chipboard[board_id].p_chain2 = info-
>chipboard[board_id].u_chain2 * info->chipboard[board_id].i_chain2;
/* fan power calculation */

if (info->chipboard[board_id].rpm != 0) {
if (info->chipboard[board_id].fan_speed > 40)
info->chipboard[board_id].p_fan = (0.1 + 0.0236
* (info->chipboard[board_id].fan_speed - 40)) *
(info->chipboard[board_id].u_board +
U_LOSS);
else
info->chipboard[board_id].p_fan = 1.23;
} else {
info->chipboard[board_id].p_fan = 0.0;
}
/* board power calculation */

#ifdef MINER_X5
float i_board = info->chipboard[board_id].i_chain1;
#endif
#ifdef MINER_X6
float i_board = info->chipboard[board_id].i_chain1 + info-
>chipboard[board_id].i_chain2;
#endif
info->chipboard[board_id].p_board = ((info-
>chipboard[board_id].u_board + U_LOSS) * i_board + 2.0 +
info->chipboard[board_id].p_fan);
if (info->chipboard[board_id].a_temp == 1)
a_temp = true;
if ((info->chipboard[board_id].a_ichain1 == 1) ||
(info->chipboard[board_id].a_ichain2 == 1))
a_ichain = true;
if (max_temp < info->chipboard[board_id].temp)

max_temp = info->chipboard[board_id].temp;
if (t_alarm > info->chipboard[board_id].t_alarm)

t_alarm = info->chipboard[board_id].t_alarm;
}
}
/* enable temp alarm */

if ((a_temp == true) && (info->a_temp == false)) {
applog(LOG_ERR, "%s: temperature alarm enabled: [%5.1f]!!!",
bitfury->drv->name, max_temp);
/* enable fans to full speed*/

if (device_uart_transfer(board_id + 1, "F:100") < 0)
quit(1, "%s: %s() failed to set BOARD%d fan
speed",
bitfury->drv->name, __func__,
board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d fan speed to max

speed",
}
}
}
/* temp alarm recovery */

if ((a_temp == false) && (info->a_temp == true)) {
applog(LOG_ERR, "%s: temperature alarm recovery: [%5.1f]",
bitfury->drv->name, max_temp);
/* restore fans speed */

set_fan_speed(bitfury);
reinit_x5(info, false);
}
/* enable power chain alarm */

if ((a_ichain == true) && (info->a_ichain == false)) {
applog(LOG_ERR, "%s: power chain alarm enabled!!!",
info->ialarm_start = time(NULL);
}
/* power chain alarm recovery */

if ((a_ichain == false) && (info->a_ichain == true)) {
if (info->ialarm_count > 1) {
applog(LOG_ERR, "%s: power chain alarm recovery",
info->ialarm_count = 1;
info->ialarm_buzzer = false;
info->ialarm_start = time(NULL);
}
}
info->a_temp = a_temp;
info->a_ichain = a_ichain;
if (info->a_temp == true)
applog(LOG_ERR, "%s: ALARM: board temp: [%5.1f] alarm temp:
[%5.1f]",
bitfury->drv->name, max_temp, t_alarm);
if (info->a_ichain == true) {
curr_time = time(NULL);
if (curr_time - info->ialarm_start >= info->ialarm_count *

ICHAIN_ALARM_INTERVAL) {
info->ialarm_count *= 2;
info->ialarm_start = curr_time;
/* enable power chain */

enable_power_chain(bitfury, board_id, 0);
#ifdef MINER_X5
info->chipboard[board_id].power_enable_time =
curr_time;
#endif
#ifdef MINER_X6
info->chipboard[board_id].power1_enable_time =
curr_time;
curr_time;
#endif
}
}
} else if (opt_bf16_power_management_disabled == false) {
if (info->a_net == true) {
/* disable power chain if no internet available */
#ifdef MINER_X5
if (info->chipboard[board_id].p_chain1_enabled
== 1) {
#endif
#ifdef MINER_X6
if ((info->chipboard[board_id].p_chain1_enabled
== 1) ||
(info-
>chipboard[board_id].p_chain2_enabled == 1)) {
#endif
disable_power_chain(bitfury, board_id,
0);
}
}
}
} else {
/* enable power chain - internet recovery */
bool recovery = false;
#ifdef MINER_X5
== 0) &&
(info->chipboard[board_id].power_disabled
== false)) {
info-
>chipboard[board_id].power_enable_time = time(NULL);

}
#endif
#ifdef MINER_X6
== 0) &&
(info-
>chipboard[board_id].power1_disabled == false)){
info-
>chipboard[board_id].power1_enable_time = time(NULL);
recovery = true;
}
== 0) &&
(info-
>chipboard[board_id].power2_disabled == false)) {
info-
>chipboard[board_id].power2_enable_time = time(NULL);
recovery = true;
}
#endif
}
}
/* reinit chips on alarm recovery */

if (recovery == true) {
}
}
}
/* board temperature regulation */

char uart_cmd[8];
if (manual_pid_enabled == false) {
sprintf(uart_cmd, "N:%d", (int)max_temp);
quit(1, "%s: %s() failed to set BOARD%d next
temp",
board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d next temp to

[%5.1f]",
max_temp);
}
}
} else {
uint8_t max_fan_speed = 0;
uint16_t pid_temp = 10 * info-
>chipboard[board_id].temp;
if (10 * max_temp > pid_temp)
pid_temp = 10 * max_temp;
int16_t fan_speed = update_pid(&info-

>chipboard[board_id].pid,
(pid_temp - 10 * info-
>chipboard[board_id].target_temp) / 10);
if (fan_speed > 100)

fan_speed = 100;
else if (fan_speed < 0)
fan_speed = 0;
if (max_fan_speed < fan_speed)

max_fan_speed = fan_speed;
}
}
sprintf(uart_cmd, "F:%d", max_fan_speed);

quit(1, "%s: %s() failed to set BOARD%d fan
speed",
board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d fan speed to [%d]",

max_fan_speed);
}
}
}
/* board power management */

curr_time = time(NULL);

#ifdef MINER_X5
uint8_t disabled_chips = 0;
uint8_t total_chips = 0;
#endif
#ifdef MINER_X6
uint8_t disabled_chips_chain1 = 0;
uint8_t total_chips_chain1 = 0;
uint8_t disabled_chips_chain2 = 0;
uint8_t total_chips_chain2 = 0;
#endif
for (bcm250_id = 0; bcm250_id < BCM250_NUM;
bcm250_id++) {
/* chips loop */
last_good_chip; chip_id++) {
#ifdef MINER_X5
total_chips++;
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status == DISABLED)
disabled_chips++;
#endif
#ifdef MINER_X6
if (bcm250_id < BCM250_NUM / 2) {
total_chips_chain1++;
if (info-
disabled_chips_chain1++;
}
if ((bcm250_id >= BCM250_NUM / 2) &&

(bcm250_id < BCM250_NUM)) {
total_chips_chain2++;
if (info-
disabled_chips_chain2++;
}
#endif
}
}
#ifdef MINER_X5
/* disable chain power if all chips failed */
if ((total_chips == disabled_chips) &&
(info->chipboard[board_id].p_chain1_enabled ==
1)) {
disable_power_chain(bitfury, board_id, 0);
/* increase disable counter until we reach long

enough work time */
time_t work_interval = curr_time - info-
>chipboard[board_id].power_enable_time;
if (work_interval < CHAIN_WORK_INTERVAL)
info-
>chipboard[board_id].power_disable_count *= 2;
info->chipboard[board_id].power_disabled =
true;
info->chipboard[board_id].power_disable_time =
curr_time;
info->chipboard[board_id].chips_disabled =
info->chipboard[board_id].chips_num;
}
/* enable disabled chain */

if ((info->chipboard[board_id].p_chain1_enabled == 0)
&&
(info->chipboard[board_id].power_disabled ==
true) &&
(curr_time - info-
>chipboard[board_id].power_disable_time >= info-
>chipboard[board_id].power_disable_count * CHAIN_REENABLE_INTERVAL)) {
time_t disable_interval = curr_time - info-
>chipboard[board_id].power_disable_time;
info->chipboard[board_id].power_disable_time =
curr_time;
0;

info->chipboard[board_id].power_enable_time =
curr_time;
info->chipboard[board_id].power_disabled =
false;

reinit_x5(info, true);
applog(LOG_NOTICE, "%s: reenabled power on
BOARD%d: time interval [%d]",
bitfury->drv->name,
board_id + 1,
(int)disable_interval);
#ifdef FILELOG
filelog(info, "%s: reenabled power on BOARD%d:
time interval [%d]",
bitfury->drv->name,
board_id + 1,
#endif
}
#endif
#ifdef MINER_X6
/* disable power on chain 1 only if chips on both
chains failed
* as chain 2 data channel depends on chain 1
*/
if ((total_chips_chain1 == disabled_chips_chain1) &&
1) &&
(info->chipboard[board_id].power2_disabled ==
true)) {

enough work time */
>chipboard[board_id].power1_enable_time;
info-
>chipboard[board_id].power1_disable_count *= 2;
info->chipboard[board_id].power1_disabled =
true;
true;
info->chipboard[board_id].power1_disable_time =
curr_time;
curr_time;
info->chipboard[board_id].chips_num;
} else
if ((total_chips_chain2 == disabled_chips_chain2) &&
1)) {

enough work time */
>chipboard[board_id].power2_enable_time;
info-
>chipboard[board_id].power2_disable_count *= 2;
true;
curr_time;
info->chipboard[board_id].chips_num / 2;
}
/* HW FIX: try to reenable disabled chain */

&&
true) &&
(curr_time - info-
>chipboard[board_id].power1_disable_time >= info-
>chipboard[board_id].power1_disable_count * CHAIN_REENABLE_INTERVAL)) {
>chipboard[board_id].power1_disable_time;
curr_time;
curr_time;
0;

curr_time;
curr_time;
false;
false;

applog(LOG_NOTICE, "%s: reenabled power on
bitfury->drv->name,
board_id + 1,
#ifdef FILELOG
filelog(info, "%s: reenabled power on BOARD%d:
time interval [%d]",
bitfury->drv->name,
board_id + 1,
#endif
} else
&&
true) &&
(curr_time - info-
>chipboard[board_id].power2_disable_time >= info-
>chipboard[board_id].power2_disable_count * CHAIN_REENABLE_INTERVAL)) {
>chipboard[board_id].power2_disable_time;
curr_time;
0;

curr_time;
false;

applog(LOG_NOTICE, "%s: reenabled chainboard 2
on BOARD%d: time interval [%d]",
bitfury->drv->name,
board_id + 1,
#ifdef FILELOG
filelog(info, "%s: reenabled chainboard 2 on
bitfury->drv->name,
board_id + 1,
#endif
}
#endif
/* switch renonce chip to next board */
if ((info->renonce_chips == 1) &&
(renonce_chip_address[board_id].board_id ==
board_id) &&
#ifdef MINER_X5
(info->chipboard[board_id].power_disabled ==
true)) {
#endif
#ifdef MINER_X6
true) &&
true)) {
#endif
uint8_t next_board_id = (board_id + 1) %
CHIPBOARD_NUM;
uint8_t next_bcm250_id =
renonce_chip_address[board_id].bcm250_id;
uint8_t next_chip_id =
renonce_chip_address[board_id].chip_id;
/* board id should be set last */

renonce_chip_address[next_board_id].bcm250_id =
next_bcm250_id;
renonce_chip_address[next_board_id].chip_id =
next_chip_id;
renonce_chip_address[next_board_id].board_id =
next_board_id;
info-
>chipboard[next_board_id].bcm250[next_bcm250_id].chips[next_chip_id].status =
UNINITIALIZED;
applog(LOG_NOTICE, "%s: changed renonce chip

address to: [%d:%d:%2d]",
bitfury->drv->name,
next_board_id, next_bcm250_id,
next_chip_id);
}
}
}
}
cgsleep_us(HWMONITOR_DELAY);
}
applog(LOG_INFO, "%s: hwmonitor_thr: exiting...", bitfury->drv->name);

return NULL;
}
static void *bitfury_alarm(void *userdata)

{
>device_data);
struct pool *pool;

int i;
time_t curr_time_t;
applog(LOG_INFO, "%s: started alarm thread", bitfury->drv->name);
/* blink lamps once */

led_red_enable(info);
led_green_enable(info);
cgsleep_ms(1000);
led_red_disable(info);
led_green_disable(info);
buzzer_disable(info);
applog(LOG_INFO, "%s: alarm loop started", bitfury->drv->name);

curr_time_t = time(NULL);
/* check if there are enabled pools present */
bool idle = true;
for (i = 0; i < total_pools; i++) {
pool = pools[i];
if (pool->idle == false)
idle = false;
}
if (idle == true)
info->a_net = true;
else
info->a_net = false;
/* temperature alarm processing */

if ((info->a_temp == true) && (info->a_ichain == false)) {
if (timediff_us(info->led_red_switch, curr_time) >=
LED_RED_INTERVAL) {
if (info->led_red_enabled == true)
else
}
/* enable buzzer */
if (timediff_us(info->buzzer_switch, curr_time) >=
BUZZER_INTERVAL) {
if (info->buzzer_enabled == true)
else
buzzer_enable(info);
}
} else if ((info->a_ichain == false) && (info->a_net == false)) {
}
/* power chain alarm processing */

if ((info->a_ichain == true) && (info->a_temp == false)) {
LED_RED_INTERVAL) {
else
}
if (info->ialarm_buzzer == false) {
cgsleep_ms(1000);
info->ialarm_buzzer = true;
}
/* enable buzzer */
if (curr_time_t - info->ialarm_start >= info->ialarm_count *
ICHAIN_ALARM_INTERVAL) {
cgsleep_ms(1000);
}
} else if ((info->a_temp == false) && (info->a_net == false)) {
}
/* blink green lamp if there are enabled pools present and no alarms
active */
if ((info->a_net == false) && (info->a_temp == false) && (info-
>a_ichain == false)) {
if (timediff_us(info->led_green_switch, curr_time) >=

LED_GREEN_INTERVAL) {
if (info->led_green_enabled == true)
else
led_green_enable(info);
}
} else {
if (info->led_green_enabled == true)
if ((info->a_temp == false) && (info->a_ichain == false)) {

LED_RED_NET_INTERVAL) {
else
}
}
}
cgsleep_us(ALARM_DELAY);
}
applog(LOG_INFO, "%s: alarm_thr: exiting...", bitfury->drv->name);

return NULL;
}
static void *bitfury_statistics(void *userdata)

{
>device_data);

float u_board;
float i_total;
float p_total;
float u_chip;
float p_chip;
time_t time0 = time(NULL);

time_t time1 = time(NULL);
time_t time2;
/* statistics calculation loop */

time2 = time(NULL);
if (time2 - time1 >= AVG_TIME_DELTA) {
u_board = 0.0;
i_total = 0.0;
p_total = 0.0;
u_chip = 0.0;
p_chip = 0.0;
info->chips_failed = 0;
info->chips_disabled = 0;

info->chipboard[board_id].chips_failed = 0;
info->chips_disabled += info-
>chipboard[board_id].chips_disabled;
for (bcm250_id = 0; bcm250_id < BCM250_NUM;
bcm250_id++) {
info-
>chipboard[board_id].bcm250[bcm250_id].chips_failed = 0;
/* chips loop */
last_good_chip; chip_id++) {
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status >= FAILING) {
info-
>chipboard[board_id].bcm250[bcm250_id].chips_failed++;
info-
>chipboard[board_id].chips_failed++;
info->chips_failed++;
}
if (opt_bf16_stats_enabled) {
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_switch,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_switch_dx,
(float)(time2 -
time1), AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_none,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_none_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_good,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_good_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_diff,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_diff_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_bad,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_bad_dx,
(float)(time2 -
if (opt_bf16_renonce !=
RENONCE_DISABLED) {
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_re,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_re_good,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_good_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_re_bad,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_bad_dx,
(float)(time2 -
}
}
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_switch_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_none_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_good_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_diff_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_bad_dx = 0;
if (opt_bf16_renonce != RENONCE_DISABLED)
{
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_good_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces_re_bad_dx = 0;
}
if (opt_bf16_renonce !=
RENONCE_DISABLED)
applog(LOG_NOTICE, "STATS:
chp [%d:%d:%2d], tsk/s [%4.0f], "
"ncs/s [%4.0f],
sts/s [%3.0f], none/s [%3.0f], hr/s [%8.3f] hr+/s [%8.3f] rhr/s [%8.3f]",
board_id,
bcm250_id, chip_id,
info-
info-
info-
info-
CHIP_COEFF * info-
CHIP_COEFF * info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_good,
CHIP_COEFF *
(info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_good +
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_re_good));
else
applog(LOG_NOTICE, "STATS:
chp [%d:%d:%2d], tsk/s [%4.0f], "
"ncs/s [%3.0f],
sts/s [%3.0f], none/s [%3.0f], hr/s [%8.3f] hr+/s [%8.3f]",
board_id,
bcm250_id, chip_id,
info-
info-
info-
info-
CHIP_COEFF * info-
CHIP_COEFF * info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_good);
}
}
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].task_switch,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].task_switch_dx,
(float)(time2 - time1),
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd_none,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd_none_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].nonces,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate_good,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_good_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate_diff,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_diff_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate_bad,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_bad_dx,
AVG_TIME_INTERVAL);
if (opt_bf16_renonce != RENONCE_DISABLED)
{
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate_re,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_re_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate_re_good,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_re_good_dx,
(float)(time2 -
get_average(&info-
>chipboard[board_id].bcm250[bcm250_id].hashrate_re_bad,
(float)info-
>chipboard[board_id].bcm250[bcm250_id].nonces_re_bad_dx,
(float)(time2 -
}
}
info-
>chipboard[board_id].bcm250[bcm250_id].task_switch_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].status_cmd_none_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_good_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_diff_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_bad_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_re_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_re_good_dx = 0;
info-
>chipboard[board_id].bcm250[bcm250_id].nonces_re_bad_dx = 0;
}
}
get_average(&info-
>chipboard[board_id].task_switch,
(float)info-
>chipboard[board_id].task_switch_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].status_cmd,
(float)info-
>chipboard[board_id].status_cmd_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].status_cmd_none,
(float)info-
>chipboard[board_id].status_cmd_none_dx,
AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].nonces,
(float)info-
>chipboard[board_id].nonces_dx,
AVG_TIME_INTERVAL);
}
get_average(&info->chipboard[board_id].hashrate,
(float)info-
>chipboard[board_id].nonces_dx,
AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_good,
(float)info-
>chipboard[board_id].nonces_good_dx,
AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_diff,
(float)info-
>chipboard[board_id].nonces_diff_dx,
AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_bad,
(float)info-
>chipboard[board_id].nonces_bad_dx,
AVG_TIME_INTERVAL);
info->chipboard[board_id].task_switch_dx = 0;
info->chipboard[board_id].status_cmd_dx = 0;
info->chipboard[board_id].status_cmd_none_dx = 0;
info->chipboard[board_id].nonces_dx = 0;
info->chipboard[board_id].nonces_good_dx = 0;
info->chipboard[board_id].nonces_diff_dx = 0;
info->chipboard[board_id].nonces_bad_dx = 0;
u_board += (info->chipboard[board_id].u_board
+ U_LOSS);
#ifdef MINER_X5
i_total += (info-
>chipboard[board_id].i_chain1);
u_chip += (info-
>chipboard[board_id].u_chain1);
p_chip += (info-
>chipboard[board_id].p_chain1);
#endif
#ifdef MINER_X6
i_total += (info->chipboard[board_id].i_chain1
+ info->chipboard[board_id].i_chain2);
u_chip += (info->chipboard[board_id].u_chain1
+ info->chipboard[board_id].u_chain2);
p_chip += (info->chipboard[board_id].p_chain1
+ info->chipboard[board_id].p_chain2);
#endif
p_total += info->chipboard[board_id].p_board;
get_average(&info-
>chipboard[board_id].hashrate_re,
(float)info-
>chipboard[board_id].nonces_re_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].hashrate_re_good,
(float)info-
>chipboard[board_id].nonces_re_good_dx,
AVG_TIME_INTERVAL);
get_average(&info-
>chipboard[board_id].hashrate_re_bad,
(float)info-
>chipboard[board_id].nonces_re_bad_dx,
AVG_TIME_INTERVAL);
info->chipboard[board_id].nonces_re_dx =
0;
info->chipboard[board_id].nonces_re_good_dx =
0;
info->chipboard[board_id].nonces_re_bad_dx =
0;
}
get_average(&info->chipboard[board_id].txrx_speed,
(float)info-
>chipboard[board_id].bytes_transmitted_dx,
AVG_TIME_INTERVAL);
info->chipboard[board_id].bytes_transmitted_dx = 0;
applog(LOG_NOTICE, "STATS: board [%d]
hrate: good: [%8.3f] re_good: [%8.3f] => "
"[%8.3f] toren: [%8.3f] bad:
[%8.3f] total: [%8.3f]",
board_id,
CHIP_COEFF * (info-
>chipboard[board_id].hashrate_good),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate_re_good),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate_good + info->chipboard[board_id].hashrate_re_good),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate - info->chipboard[board_id].hashrate_good),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate_bad),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate));
} else {
applog(LOG_NOTICE, "STATS: board [%d]
hrate: good: [%8.3f] "
"bad: [%8.3f] total:
[%8.3f]",
board_id,
CHIP_COEFF * (info-
>chipboard[board_id].hashrate_good),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate_bad),
CHIP_COEFF * (info-
>chipboard[board_id].hashrate));
}
#ifdef MINER_X5
applog(LOG_NOTICE, "STATS: TX/RX: [%5.3f]
Mbit/s UB: [%3.1f] "
"U1: [%3.1f] I1: [%3.1f] T: [%3.1f]
RPM: [%4d] FAN: [%3d]",
8.0 * info-
>chipboard[board_id].txrx_speed / 1000000,
info->chipboard[board_id].u_board +
U_LOSS,
info->chipboard[board_id].u_chain1,
info->chipboard[board_id].i_chain1,
info->chipboard[board_id].temp,
info->chipboard[board_id].rpm,
info-
>chipboard[board_id].fan_speed);
#endif
#ifdef MINER_X6
applog(LOG_NOTICE, "STATS: TX/RX: [%5.3f]
Mbit/s UB: [%3.1f] "
"U1: [%3.1f] U2: [%3.1f] I1:
[%3.1f] I2: [%3.1f] T: [%3.1f] RPM: [%4d] FAN: [%3d]",
8.0 * info-
>chipboard[board_id].txrx_speed / 1000000,
info->chipboard[board_id].u_board +
U_LOSS,
info->chipboard[board_id].temp,
info->chipboard[board_id].rpm,
info-
>chipboard[board_id].fan_speed);
#endif
applog(LOG_NOTICE, "STATS: ver: [%d] fw: [%d]

hwid: [%s]",
info-
>chipboard[board_id].board_ver,
info-
>chipboard[board_id].board_fwver,
info-
>chipboard[board_id].board_hwid);
}
}
}
get_average(&info->task_switch,
(float)info->task_switch_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->status_cmd,
(float)info->status_cmd_dx,
get_average(&info->status_cmd_none,
(float)info->status_cmd_none_dx,
get_average(&info->chipboard[board_id].nonces,
(float)info->chipboard[board_id].nonces_dx,
}
get_average(&info->hashrate,
(float)info->nonces_dx,
get_average(&info->hashrate_good,
(float)info->nonces_good_dx,
get_average(&info->hashrate_diff,
(float)info->nonces_diff_dx,
get_average(&info->hashrate_bad,
(float)info->nonces_bad_dx,
info->task_switch_dx = 0;
info->status_cmd_dx = 0;
info->status_cmd_none_dx = 0;
info->nonces_dx = 0;
info->nonces_good_dx = 0;
info->nonces_diff_dx = 0;
info->nonces_bad_dx = 0;
get_average(&info->hashrate_re,
(float)info->nonces_re_dx,
get_average(&info->hashrate_re_good,
(float)info->nonces_re_good_dx,
get_average(&info->hashrate_re_bad,
(float)info->nonces_re_bad_dx,
info->nonces_re_dx = 0;
info->nonces_re_good_dx = 0;
info->nonces_re_bad_dx = 0;
}
time1 = time2;
uint32_t uptime = time2 - time0;

uint32_t hours = uptime / 3600;
uint8_t minutes = (uptime - hours * 3600) / 60;
uint8_t seconds = uptime - hours * 3600 - minutes * 60;
info->u_avg = u_board / info->active_chipboard_num;

info->i_total = i_total;
info->p_total = p_total;
info->u_chip = u_chip;
info->p_chip = p_chip;
applog(LOG_NOTICE, "STATS: rencs: [%d] stale: [%d]
nws: [%d] rnws: [%d] failed: [%d]",
info->renonce_list->count,
info->stale_work_list->count,
info->noncework_list->count,
info->renoncework_list->count,
info->chips_failed);
applog(LOG_NOTICE, "STATS: %4.0fGH/s osc: 0x%02x

re_osc: 0x%02x "
"%3.1fV %3.1fA %4.1fW %.3fW/GH",
CHIP_COEFF * (info->hashrate_good + info-
>hashrate_re_good),
bf16_chip_clock,
bf16_renonce_chip_clock,
info->u_avg,
info->i_total,
info->p_total,
(info->a_net == true) ?
0.0 :
info->p_total / (CHIP_COEFF *
(info->hashrate_good + info->hashrate_re_good)));
applog(LOG_NOTICE, "STATS: TOTAL: %5.1fGH/s %5.3fV

%3.1fA %5.2fW "
"CHIP: %5.1fGH/s GOOD: %4.1fGH/s RENONCE:
%4.1fGH/s BAD: %4.1fGH/s",
CHIP_COEFF * info->hashrate / (info-
>chips_num - info->renonce_chips - info->chips_failed),
info->u_chip / (info->chips_num - info-
>chips_disabled),
(info->a_net == true) ? 0.0 : info-
>p_chip / info->u_chip,
info->p_chip / (info->chips_num - info-
>chips_disabled),
CHIP_COEFF * (info->hashrate_good + info-
>hashrate_re_good) / (info->chips_num - info->renonce_chips - info->chips_failed),
CHIP_COEFF * info->hashrate_good / (info-
>chips_num - info->renonce_chips - info->chips_failed),
CHIP_COEFF * info->hashrate_re_good /
(info->chips_num - info->renonce_chips - info->chips_failed),
CHIP_COEFF * info->hashrate_re_bad /
(info->chips_num - info->renonce_chips - info->chips_failed));
#if 1
applog(LOG_NOTICE, "STATS: m0: [%lu] mm0: [%lu] m1:
[%lu] mm1: [%lu] m2: [%lu] mm2: [%lu] "
"m3: [%lu] mm3: [%lu] um: [%lu]",
info->stage0_match / (time2 - time0),
info->stage0_mismatch / (time2 - time0),
info->unmatched / (time2 - time0));
#endif
} else {
applog(LOG_NOTICE, "STATS: stale: [%d] nws: [%d]",
info->stale_work_list->count, info-
>noncework_list->count);
applog(LOG_NOTICE, "STATS: %4.0fGH/s osc: 0x%02x"

"%3.1fV %3.1fA %4.1fW %.3fW/GH",
CHIP_COEFF * info->hashrate_good,
bf16_chip_clock,
info->u_avg,
info->i_total,
info->p_total,
0.0 :
info->p_total / (CHIP_COEFF * info-
>hashrate_good));
applog(LOG_NOTICE, "STATS: TOTAL: %5.1fGH/s %5.3fV

%3.1fA %5.2fW "
"CHIP: %5.1fGH/s GOOD: %4.1fGH/s BAD:
%4.1fGH/s",
CHIP_COEFF * info->hashrate / (info-
>chips_num - info->chips_failed),
info->u_chip / (info->chips_num - info-
>chips_disabled),
(info->a_net == true) ? 0.0 : info-
>p_chip / info->u_chip,
info->p_chip / (info->chips_num - info-
>chips_disabled),
CHIP_COEFF * info->hashrate_bad / (info-
>chips_num - info->chips_failed));
}
applog(LOG_NOTICE, "STATS: uptime: [%4d:%02d:%02d] time

elapsed: [%.6f] ",
hours, minutes, seconds, timediff(start_time,
stop_time));
}
}
cgsleep_us(STATISTICS_DELAY);
}
applog(LOG_INFO, "%s: statistics_thr: exiting...", bitfury->drv->name);

return NULL;
}
static bool bitfury16_thread_prepare(struct thr_info *thr)

{
struct cgpu_info *bitfury = thr->cgpu;
>device_data);
info->thr = thr;
if (thr_info_create(&(info->chipworker_thr), NULL, bitfury_chipworker, (void

*)bitfury)) {
applog(LOG_ERR, "%s: %s() chipworker thread create failed",
return false;
}
pthread_detach(info->chipworker_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting chipworker thread", bitfury-

>drv->name);
if (thr_info_create(&(info->nonceworker_thr), NULL, bitfury_nonceworker,

(void *)bitfury)) {
applog(LOG_ERR, "%s: %s() nonceworker thread create failed",
return false;
}
pthread_detach(info->nonceworker_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting nonceworker thread", bitfury-

>drv->name);
if (thr_info_create(&(info->renonceworker_thr), NULL,
bitfury_renonceworker, (void *)bitfury)) {
applog(LOG_ERR, "%s: %s() renonceworker thread create failed",
return false;
}
pthread_detach(info->renonceworker_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting renonceworker thread",

}
if (thr_info_create(&(info->hwmonitor_thr), NULL, bitfury_hwmonitor, (void

*)bitfury)) {
applog(LOG_ERR, "%s: %s() hwmonitor thread create failed",
return false;
}
pthread_detach(info->hwmonitor_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting hwmonitor thread", bitfury-

>drv->name);
if (thr_info_create(&(info->alarm_thr), NULL, bitfury_alarm, (void

*)bitfury)) {
applog(LOG_ERR, "%s: %s() alarm thread create failed",
return false;
}
pthread_detach(info->alarm_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting alarm thread", bitfury->drv-

>name);
if (thr_info_create(&(info->statistics_thr), NULL, bitfury_statistics, (void

*)bitfury)) {
applog(LOG_ERR, "%s: %s() statistics thread create failed",
return false;
}
pthread_detach(info->statistics_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting statistics thread", bitfury-

>drv->name);
return true;
}
static int64_t bitfury16_scanwork(struct thr_info *thr)

{
struct bitfury16_info *info = bitfury->device_data;
int64_t hashcount = 0;
applog(LOG_INFO, "%s: scan work", bitfury->drv->name);
if (info->nonces_good_cg) {
hashcount += 0xffffffffull * info->nonces_good_cg;
info->nonces_good_cg = 0;
}
return hashcount;
}
static void prepare_work(struct cgpu_info *bitfury, struct work *work, bool rolled)
{
bf_workd_t* wdata = cgmalloc(sizeof(bf_workd_t));
wdata->work = work;
wdata->rolled = rolled;
wdata->generated = time(NULL);
/* generate task payload */

cg_memcpy(wdata->payload.midstate, work->midstate, 32);
wdata->payload.m7 = *(uint32_t *)(work->data + 64);
wdata->payload.ntime = *(uint32_t *)(work->data + 68);
wdata->payload.nbits = *(uint32_t *)(work->data + 72);
workd_list_push(info->work_list, wdata);
}
static bool bitfury16_queue_full(struct cgpu_info *bitfury)

{
struct work *work, *usework;
uint16_t need = 0;
uint16_t generated = 0;
uint16_t roll, roll_limit;
bool rolled;
if (info->initialised == false) {
cgsleep_us(30);
return true;
}
uint16_t work_count = info->work_list->count;
if (work_count < WORK_QUEUE_LEN)
need = WORK_QUEUE_LEN - work_count;
else
return true;
/* Ensure we do enough rolling to reduce CPU

but dont roll too much to have them end up stale */
work = get_queued(bitfury);
if (work) {
roll_limit = work->drv_rolllimit;
roll = 0;
do {
if (roll == 0) {
usework = work;
rolled = false;
} else {
usework = copy_work_noffset(work, roll);
rolled = true;
}
prepare_work(bitfury, usework, rolled);

generated++;
} while ((--need > 0) && (++roll <= roll_limit));
applog(LOG_INFO, "%s: queue full: generated %d works", bitfury->drv-
>name, generated);
} else
cgsleep_us(30);
if (need > 0)
return false;
else
return true;
}
static void bitfury16_flush_work(struct cgpu_info *bitfury)

{
uint16_t flushed = 0;
if (info->initialised == false)
return;
bf_works_t works;
/* flush work list */

bf_data_t* wdata = info->work_list->head;
while (wdata != NULL) {
workd_list_push(info->stale_work_list, WORKD(wdata));
workd_list_remove(info->work_list, &works);
wdata = info->work_list->head;
flushed++;
}
/* flush nonces list */

bf_data_t* nwdata = info->noncework_list->head;
while (nwdata != NULL) {
noncework_list_pop(info->noncework_list);
nwdata = info->noncework_list->head;
}
/* flush renonces list */
renonce_list_pop(info->renonce_list);
rdata = info->renonce_list->head;
}
/* flush renoncework list */

bf_data_t* rnwdata = info->renoncework_list->head;
while (rnwdata != NULL) {
renoncework_list_pop(info->renoncework_list);
rnwdata = info->renoncework_list->head;
}
}
applog(LOG_INFO, "%s: flushed %d works", bitfury->drv->name, flushed);

}
static struct api_data *bitfury16_api_stats(struct cgpu_info *bitfury)

{
struct bitfury16_info *info = bitfury->device_data;
char data[128];
char value[128];
struct api_data *root = NULL;
applog(LOG_INFO, "%s: API stats", bitfury->drv->name);
if (info->initialised == false)
return NULL;
#ifdef MINER_X5
root = api_add_string(root, "Device name", "Bitfury X5", true);
#endif
#ifdef MINER_X6
root = api_add_string(root, "Device name", "Bitfury X6", true);
#endif
root = api_add_uint8(root, "Boards number", &info->chipboard_num, false);
root = api_add_uint8(root, "Boards detected", &info->chipboard_num, false);
root = api_add_uint8(root, "Chips number", &info->chips_num, false);
/* software revision chages according to comments in CHANGELOG */

root = api_add_string(root, "hwv1", "1", true);
/* U avg */
sprintf(value, "%.1f", info->u_avg);
root = api_add_string(root, "U avg", value, true);
/* I total */
sprintf(value, "%.1f", info->i_total);
root = api_add_string(root, "I total", value, true);
/* P total */
sprintf(value, "%.1f", info->p_total);
root = api_add_string(root, "P total", value, true);
/* Efficiency */
sprintf(value, "%.3f",
0.0 :
info->p_total / (CHIP_COEFF * (info->hashrate_good +
info->hashrate_re_good)));
root = api_add_string(root, "Efficiency", value, true);
/* Chip GHS total avg */
sprintf(value, "%.1f", CHIP_COEFF * info->hashrate / (info->chips_num -
info->renonce_chips - info->chips_failed));
root = api_add_string(root, "Chip GHS total avg", value, true);
/* Chip GHS avg */

sprintf(value, "%.1f", CHIP_COEFF * (info->hashrate_good + info-
>hashrate_re_good) / (info->chips_num - info->renonce_chips - info->chips_failed));
root = api_add_string(root, "Chip GHS avg", value, true);
/* Chip GHS good avg */

sprintf(value, "%.1f", CHIP_COEFF * info->hashrate_good / (info-
>chips_num - info->renonce_chips - info->chips_failed));
root = api_add_string(root, "Chip GHS good avg", value, true);
/* Chip GHS re avg */

sprintf(value, "%.1f", CHIP_COEFF * info->hashrate_re_good / (info-
root = api_add_string(root, "Chip GHS re avg", value, true);
/* Chip GHS bad avg */

sprintf(value, "%.1f", CHIP_COEFF * info->hashrate_re_bad / (info-
root = api_add_string(root, "Chip GHS bad avg", value, true);
} else {
/* Efficiency */
0.0 :
info->p_total / (CHIP_COEFF * info->hashrate_good));
root = api_add_string(root, "Efficiency", value, true);
/* Chip GHS total avg */

sprintf(value, "%.1f", CHIP_COEFF * info->hashrate / (info->chips_num -
info->chips_failed));
root = api_add_string(root, "Chip GHS total avg", value, true);
/* Chip GHS avg */

root = api_add_string(root, "Chip GHS avg", value, true);
/* Chip GHS good avg */

root = api_add_string(root, "Chip GHS good avg", value, true);
/* Chip GHS re avg */

sprintf(value, "%.1f", 0.0);
root = api_add_string(root, "Chip GHS re avg", value, true);
/* Chip GHS bad avg */

sprintf(value, "%.1f", CHIP_COEFF * info->hashrate_bad / (info-
root = api_add_string(root, "Chip GHS bad avg", value, true);
}
/* U Chip avg */
sprintf(value, "%.3f", info->u_chip / (info->chips_num - info-
>chips_disabled));
root = api_add_string(root, "U Chip avg", value, true);
/* I Chip avg */
sprintf(value, "%.1f", (info->a_net == true) ? 0.0 : info->p_chip / info-
>u_chip);
root = api_add_string(root, "I Chip avg", value, true);
/* P Chip avg */
sprintf(value, "%.2f", info->p_chip / (info->chips_num - info-
>chips_disabled));
root = api_add_string(root, "P Chip avg", value, true);

/* board status */
sprintf(data, "Board%d detected", board_id);
if (info->chipboard[board_id].detected == true)
root = api_add_string(root, data, "1", true);
else
root = api_add_string(root, data, "0", true);
/* number of concentratord on board */

sprintf(data, "Board%d BTC250", board_id);
root = api_add_uint8(root, data, &info->chipboard[board_id].bcm250_num,
false);
/* number of chips on board */

sprintf(data, "Board%d BTC16", board_id);
root = api_add_uint8(root, data, &info->chipboard[board_id].chips_num,
false);
/* number of good chips on board */

sprintf(data, "Board%d BTC16 good", board_id);
uint8_t chips_good = info->chipboard[board_id].chips_num - info-
>chipboard[board_id].chips_failed;
root = api_add_uint8(root, data, &chips_good, true);
sprintf(data, "Board%d Clock", board_id);

if (info->chipboard[board_id].detected == true)
sprintf(value, "%d (0x%02x)", bf16_chip_clock, bf16_chip_clock);
else
sprintf(value, "%d (0x%02x)", 0, 0);
root = api_add_string(root, data, value, true);
sprintf(data, "Board%d GHS av", board_id);

CHIP_COEFF * (info->chipboard[board_id].hashrate_good
+ info->chipboard[board_id].hashrate_re_good));
} else {
sprintf(value, "%.2f", CHIP_COEFF * (info-
>chipboard[board_id].hashrate_good));
}
/* number of chips per concentrator */

uint8_t i = 0;
memset(value, 0, sizeof(value));

sprintf(data, "Board%d BTC250_%d BTC16", board_id, bcm250_id);
root = api_add_uint8(root, data, &info-
>chipboard[board_id].bcm250[bcm250_id].chips_num, false);

/* chips loop */
chip_id++, i++) {
bf_chip_address_t chip_address;
chip_address.board_id = board_id;
chip_address.bcm250_id = bcm250_id;
chip_address.chip_id = chip_id;
if (info-
>chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING) {
(renonce_chip(chip_address) == 1))
value[i] = 'O';
else
value[i] = 'o';
} else {
(renonce_chip(chip_address) == 1))
value[i] = 'X';
else
value[i] = 'x';
}
}
if (bcm250_id != BCM250_NUM - 1)
value[i++] = ' ';
}
sprintf(data, "Board%d BF16 Status", board_id);

/* MSP version data */

/* board version */
sprintf(data, "Board%d Ver", board_id);
root = api_add_uint32(root, data, &info->chipboard[board_id].board_ver,
false);
/* board firmware version */

sprintf(data, "Board%d FW", board_id);
>chipboard[board_id].board_fwver, false);
/* board hardware id */
sprintf(data, "Board%d HWID", board_id);
root = api_add_string(root, data, info->chipboard[board_id].board_hwid,
true);
/* MSP hw data */
/* T */
sprintf(data, "Board%d T", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].temp);
/* UB */
sprintf(data, "Board%d UB", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].u_board);
/* P1 */
sprintf(data, "Board%d P1", board_id);
>chipboard[board_id].p_chain1_enabled, false);
/* P2 */
sprintf(data, "Board%d P2", board_id);
>chipboard[board_id].p_chain2_enabled, false);
/* U1 */
sprintf(data, "Board%d U1", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].u_chain1);
/* U2 */
sprintf(data, "Board%d U2", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].u_chain2);
/* I1 */
sprintf(data, "Board%d I1", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].i_chain1);
/* I2 */
sprintf(data, "Board%d I2", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].i_chain2);
/* RPM */
sprintf(data, "Board%d PRM", board_id);
root = api_add_uint32(root, data, &info->chipboard[board_id].rpm,
true);
/* A */
sprintf(data, "Board%d T_Alarm", board_id);
root = api_add_uint8(root, data, &info->chipboard[board_id].a_temp,
true);
sprintf(data, "Board%d I1_Alarm", board_id);

root = api_add_uint8(root, data, &info->chipboard[board_id].a_ichain1,
true);
sprintf(data, "Board%d I2_Alarm", board_id);

root = api_add_uint8(root, data, &info->chipboard[board_id].a_ichain2,
true);
/* F */
sprintf(data, "Board%d F", board_id);
root = api_add_uint8(root, data, &info->chipboard[board_id].fan_speed,
false);
/* AI */
sprintf(data, "Board%d AI", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].i_alarm);
/* AT */
sprintf(data, "Board%d AT", board_id);
sprintf(value, "%.0f", info->chipboard[board_id].t_alarm);
/* AG */
sprintf(data, "Board%d AG", board_id);
sprintf(value, "%.0f", info->chipboard[board_id].t_gisteresis);
/* FM */
sprintf(data, "Board%d FM", board_id);
#ifdef MINER_X5
sprintf(value, "%c", info->chipboard[board_id].fan_mode);
#endif
#ifdef MINER_X6
if (manual_pid_enabled == true)
sprintf(value, "A");
else
sprintf(value, "%c", info->chipboard[board_id].fan_mode);
#endif
/* TT */
sprintf(data, "Board%d TT", board_id);
sprintf(value, "%.0f", info->chipboard[board_id].target_temp);
}
return root;
}
static void bitfury16_shutdown(struct thr_info *thr)

{
uint8_t board_id;
bitfury->shutdown = true;
cgsleep_ms(300);
/* flush next board temp to default value */

if (manual_pid_enabled == false) {
if (device_uart_transfer(board_id + 1, "N") < 0)
quit(1, "%s: %s() failed to set BOARD%d next temp",
1);
applog(LOG_INFO, "%s: set BOARD%d next temp to default

value",
}
}
} else {
if (device_uart_transfer(board_id + 1, "F") < 0)
quit(1, "%s: %s() failed to set BOARD%d fan speed to
auto mode",
1);
applog(LOG_INFO, "%s: set BOARD%d fan speed to auto mode",

}
}
}
/* disable power chain */

}
mutex_destroy(&info->nonces_good_lock);
/* close devices */
close_ctrl_device();
#ifdef FILELOG
filelog(info, "%s: cgminer stopped", bitfury->drv->name);
fclose(info->logfile);
mutex_destroy(&info->logfile_mutex);
#endif
applog(LOG_INFO, "%s: driver shutdown", bitfury->drv->name);

}
/* Currently hardcoded to BF1 devices */

struct device_drv bitfury16_drv = {
.drv_id = DRIVER_bitfury16,
.dname = "bitfury16",
.name = "BF16",
.drv_detect = bitfury16_detect,
.get_api_stats = bitfury16_api_stats,
.identify_device = bitfury16_identify,
.thread_prepare = bitfury16_thread_prepare,
.hash_work = hash_queued_work,
.scanwork = bitfury16_scanwork,
.queue_full = bitfury16_queue_full,
.flush_work = bitfury16_flush_work,
.thread_shutdown = bitfury16_shutdown
};

Driver Bitfury16

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Driver Bitfury16

Uploaded by

Copyright:

Available Formats

#include "config.

#define POWER_WAIT_INTERVAL 100000

/* chip nonce queue len */

#define WORK_TIMEOUT 2.0

/* power chain alarm interval */

/* power chain reenable timeout */

/* disable chip if no good nonces received during CHIP_FAILING_INTERVAL */

/* chip is considered to be failed after CHIP_ERROR_FAIL_LIMIT recovery attempts */

#define CHIP_TASK_STATUS_INTERVAL 7000

#define CHIP_RESTART_LIMIT 120

/* hold 3 works for each chip */

/* set clock to all chips and exit */

/* enable board mining statistics output */

/* disable automatic power management */

/* chip clock value */

/* renonce chip clock value */

/* test chip communication */

/* number of bits to fixate */

/* default chip mask */

/* initial pid state */

static bf_bcm250_map_t bcm250_map[CHIPBOARD_NUM][BCM250_NUM] = {

static bf_bcm250_map_t bcm250_map[CHIPBOARD_NUM][BCM250_NUM] = {

/* each array element contains chip address assosiated to corresponting chipboard *

snprintf(datetime, sizeof(datetime), " [%d-%02d-%02d %02d:%02d:%02d.%03d] ",

static double timediff(struct timeval time1, struct timeval time2)

return (double)(time2_val - time1_val) / 1000000.0;

static uint32_t timediff_us(struct timeval time1, struct timeval time2)

return (time2_val - time1_val);

static void get_average(float* average, float delta, float time_diff, float

fprop = 1.0 - 1 / (exp((float)time_diff/(float)interval));

static uint8_t renonce_chip(bf_chip_address_t chip_address)

static void get_next_chip_address(struct bitfury16_info *info, bf_chip_address_t*

uint8_t last_good_chip = info-

/* do not set bcm250_id to disabled chain */

static int8_t change_renonce_chip_address(struct cgpu_info *bitfury,

uint8_t board_id = chip_address.board_id;

bool found = false;

uint8_t new_board_id = new_chip_address.board_id;

/* enabled chip found */

/* we have run full loop chipboard */

if ((found == true) &&

applog(LOG_NOTICE, "%s: changed renonce chip address to: [%d:%d:%2d]",

applog(LOG_NOTICE, "%s: failed to find working renonce chip.

static void increase_good_nonces(struct bitfury16_info *info, bf_chip_address_t

static void increase_bad_nonces(struct bitfury16_info *info, bf_chip_address_t

static void increase_re_good_nonces(struct bitfury16_info *info, bf_chip_address_t

static void increase_re_bad_nonces(struct bitfury16_info *info, bf_chip_address_t

static void increase_total_nonces(struct bitfury16_info *info, bf_chip_address_t

static void increase_task_switch(struct bitfury16_info *info, bf_chip_address_t

static void increase_errors(struct bitfury16_info *info, bf_chip_address_t

/* update timing interval */

/* mark chip as FAILING if error rate too high*/

static uint8_t* init_channel_path(uint8_t board_id, uint8_t btc250_num, uint8_t*

for (i = 0, j = 0; i < CHANNEL_DEPTH; i++) {

int8_t shift = 8*(j + 1) - 3*(i + 1);

static int8_t parse_chip_address(struct cgpu_info *bitfury, char* address,

if ((board_id < 0) || (board_id >= CHIPBOARD_NUM)) {

if ((bcm250_id < 0) || (bcm250_id >= BCM250_NUM)) {

uint8_t first_good_chip = info-

if ((chip_id >= first_good_chip) && (chip_id < last_good_chip)) {

applog(LOG_NOTICE, "%s: parsed chip address: [%d:%d:%2d]",

/* 24 chip board version */

/* 25 chip board version */

/* 26 chip board version */

static void get_next_chip_address(struct bitfury16_info info, bf_chip_address_t

int8_t shift = 8(j + 1) - 3(i + 1);

static int8_t parse_chip_address(struct cgpu_info bitfury, char address,