代码拉取完成，页面将自动刷新
#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 },
.first_good_chip = 7,
.last_good_chip = BF16_NUM,
.chips_num = 4
},
{
.channel_path = { BF250_CHAN2, BF250_LOCAL },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_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 },
.first_good_chip = 7,
.last_good_chip = BF16_NUM,
.chips_num = 4
},
{
.channel_path = { BF250_CHAN2, BF250_LOCAL },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
}
}
};
#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 },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN1, BF250_LOCAL, BF250_NONE, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN2, BF250_LOCAL, BF250_NONE, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = 4,
.chips_num = 4
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_LOCAL, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_CHAN1, BF250_LOCAL },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_CHAN2, BF250_LOCAL },
.first_good_chip = 0,
.last_good_chip = 4,
.chips_num = 4
}
},
{
{
.channel_path = { BF250_LOCAL, BF250_NONE, BF250_NONE, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN1, BF250_LOCAL, BF250_NONE, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN2, BF250_LOCAL, BF250_NONE, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = 4,
.chips_num = 4
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_LOCAL, BF250_NONE },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_CHAN1, BF250_LOCAL },
.first_good_chip = 0,
.last_good_chip = BF16_NUM,
.chips_num = BF16_NUM
},
{
.channel_path = { BF250_CHAN2, BF250_CHAN2, BF250_CHAN2, BF250_LOCAL },
.first_good_chip = 0,
.last_good_chip = 4,
.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->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
}
#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 board_id = chip_address.board_id;
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 (opt_bf16_power_management_disabled == false) {
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 {
if (chip_count == info->chipboard[board_id].chips_num)
break;
}
} else {
if (chip_count == info->chipboard[board_id].chips_num)
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,
board_id, bcm250_id, chip_id);
#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...",
bitfury->drv->name);
#endif
return -1;
}
}
static void increase_good_nonces(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;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
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)
{
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
/* 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++;
if ((renonce_chip(chip_address) == 0) ||
(opt_bf16_renonce == RENONCE_DISABLED))
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = 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
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = 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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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;
memset(buff, 0, sizeof(buff));
cg_memcpy(buff, start + 1, len);
bcm250_id = atoi(buff);
/* chip_id */
start = end;
end = strchr(start + 1, ']');
if (end == NULL)
return -1;
len = end - start;
memset(buff, 0, sizeof(buff));
cg_memcpy(buff, start + 1, len);
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].first_good_chip;
uint8_t last_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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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;
bcm250_map[board_id][2].last_good_chip = BF16_NUM - 2;
bcm250_map[board_id][2].chips_num = BF16_NUM - 2;
break;
/* 24 chip board version */
case 7:
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;
bcm250_map[board_id][2].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][2].chips_num = BF16_NUM - 1;
break;
/* 25 chip board version */
case 9:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][0].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][0].chips_num = BF16_NUM - 1;
bcm250_map[board_id][1].first_good_chip = 6;
bcm250_map[board_id][1].chips_num = 5;
bcm250_map[board_id][2].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][2].chips_num = BF16_NUM - 1;
break;
/* 26 chip board version */
case 11:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][0].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][0].chips_num = BF16_NUM - 1;
bcm250_map[board_id][1].first_good_chip = 6;
bcm250_map[board_id][1].chips_num = 5;
break;
/* 27 chip board version */
case 13:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][1].first_good_chip = 6;
bcm250_map[board_id][1].chips_num = 5;
break;
/* 26 chip board version - default */
case 1:
case 2:
info->chipboard[board_id].board_rev = CHIPBOARD_REV1;
default:
break;
}
#endif
#ifdef MINER_X6
info->chipboard[board_id].board_type = CHIPBOARD_X6;
switch (info->chipboard[board_id].board_ver) {
/* 46 chip board version */
case 4:
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 = 1;
bcm250_map[board_id][1].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][1].chips_num = BF16_NUM - 2;
bcm250_map[board_id][2].last_good_chip = 5;
bcm250_map[board_id][2].chips_num = 5;
bcm250_map[board_id][3].last_good_chip = BF16_NUM - 2;
bcm250_map[board_id][3].chips_num = BF16_NUM - 2;
bcm250_map[board_id][4].first_good_chip = 1;
bcm250_map[board_id][4].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][4].chips_num = BF16_NUM - 1;
bcm250_map[board_id][5].last_good_chip = 5;
bcm250_map[board_id][5].chips_num = 5;
break;
/* 48 chip board version */
case 6:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][0].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][0].chips_num = BF16_NUM - 1;
bcm250_map[board_id][1].first_good_chip = 1;
bcm250_map[board_id][1].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][1].chips_num = BF16_NUM - 2;
bcm250_map[board_id][2].last_good_chip = 5;
bcm250_map[board_id][2].chips_num = 5;
bcm250_map[board_id][3].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][3].chips_num = BF16_NUM - 1;
bcm250_map[board_id][4].first_good_chip = 1;
bcm250_map[board_id][4].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][4].chips_num = BF16_NUM - 1;
bcm250_map[board_id][5].last_good_chip = 5;
bcm250_map[board_id][5].chips_num = 5;
break;
/* 50 chip board version */
case 8:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][0].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][0].chips_num = BF16_NUM - 1;
bcm250_map[board_id][1].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][1].chips_num = BF16_NUM - 1;
bcm250_map[board_id][2].last_good_chip = 5;
bcm250_map[board_id][2].chips_num = 5;
bcm250_map[board_id][3].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][3].chips_num = BF16_NUM - 1;
bcm250_map[board_id][4].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][4].chips_num = BF16_NUM - 1;
bcm250_map[board_id][5].last_good_chip = 5;
bcm250_map[board_id][5].chips_num = 5;
break;
/* 52 chip board version */
case 10:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][1].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][1].chips_num = BF16_NUM - 1;
bcm250_map[board_id][2].last_good_chip = 5;
bcm250_map[board_id][2].chips_num = 5;
bcm250_map[board_id][4].last_good_chip = BF16_NUM - 1;
bcm250_map[board_id][4].chips_num = BF16_NUM - 1;
bcm250_map[board_id][5].last_good_chip = 5;
bcm250_map[board_id][5].chips_num = 5;
break;
/* 54 chip board version */
case 12:
info->chipboard[board_id].board_rev = CHIPBOARD_REV2;
bcm250_map[board_id][2].last_good_chip = 5;
bcm250_map[board_id][2].chips_num = 5;
bcm250_map[board_id][5].last_good_chip = 5;
bcm250_map[board_id][5].chips_num = 5;
break;
/* 46 chip board version */
case 14:;
info->chipboard[board_id].board_rev = CHIPBOARD_REV3;
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][0].first_good_chip = 0;
bcm250_map[board_id][0].last_good_chip = 1;
bcm250_map[board_id][0].chips_num = 1;
bcm250_map[board_id][2].first_good_chip = 0;
bcm250_map[board_id][2].last_good_chip = BF16_NUM;
bcm250_map[board_id][2].chips_num = BF16_NUM;
bcm250_map[board_id][3].first_good_chip = 0;
bcm250_map[board_id][3].last_good_chip = 1;
bcm250_map[board_id][3].chips_num = 1;
cg_memcpy(bcm250_map[board_id][3].channel_path, bcm250_channel_path[0], sizeof(bcm250_map[board_id][3].channel_path));
cg_memcpy(bcm250_map[board_id][4].channel_path, bcm250_channel_path[1], sizeof(bcm250_map[board_id][4].channel_path));
bcm250_map[board_id][5].first_good_chip = 0;
bcm250_map[board_id][5].last_good_chip = BF16_NUM;
bcm250_map[board_id][5].chips_num = BF16_NUM;
cg_memcpy(bcm250_map[board_id][5].channel_path, bcm250_channel_path[2], sizeof(bcm250_map[board_id][5].channel_path));
break;
/* 52 chip board version - default */
case 3:
info->chipboard[board_id].board_rev = CHIPBOARD_REV1;
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++) {
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
for (chip_id = first_good_chip; chip_id < last_good_chip; chip_id++) {
if (chip_reinit == true) {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count = 0;
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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = time(NULL);
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_error_time = time(NULL);
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time, NULL);
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->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);
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].switch_time, NULL);
}
}
}
/* send reset to all boards */
spi_emit_reset(SPI_CHANNEL1);
spi_emit_reset(SPI_CHANNEL2);
}
static void init_x5(struct cgpu_info *bitfury)
{
uint8_t board_id, bcm250_id, chip_id;
struct bitfury16_info *info = (struct bitfury16_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();
}
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
/* detect board */
char buff[256];
memset(buff, 0, sizeof(buff));
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;
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
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;
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
for (chip_id = first_good_chip; chip_id < last_good_chip; 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);
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonce_list = nonce_list_init();
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time, NULL);
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].switch_time, NULL);
}
}
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)
{
uint8_t board_id, bcm250_id, chip_id;
struct bitfury16_info *info = (struct bitfury16_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);
if (opt_bf16_renonce != RENONCE_DISABLED) {
renoncework_list_deinit(info->renoncework_list);
info->renonce_id = 1;
renonce_list_deinit(info->renonce_list);
}
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
free(info->chipboard[board_id].bcm250[bcm250_id].channel_path);
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
for (chip_id = first_good_chip; chip_id < last_good_chip; 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)
{
uint8_t board_id, bcm250_id, chip_id;
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
/* send reset to all boards */
spi_emit_reset(SPI_CHANNEL1);
spi_emit_reset(SPI_CHANNEL2);
/* board loop */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
applog(LOG_NOTICE, "%s: CHIPBOARD [%d]:", bitfury->drv->name, board_id);
/* concentrator loop */
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
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 first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
uint8_t result;
bool fail;
/* chips loop */
for (chip_id = first_good_chip; chip_id < last_good_chip; 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)
{
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
/* send reset to board */
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 = 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)
{
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
uint8_t board_id;
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
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",
bitfury->drv->name, __func__, board_id + 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;
uint8_t board_id, bcm250_id, chip_id;
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->drv->name, __func__);
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 != RENONCE_DISABLED) {
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)
quit(1, "%s: %s() failed to open [%s] device",
bitfury->drv->name, __func__, spi1_device_name);
applog(LOG_INFO, "%s: opened [%s] device", bitfury->drv->name, spi1_device_name);
if (open_ctrl_device() < 0)
quit(1, "%s: %s() failed to open [%s] device",
bitfury->drv->name, __func__, ctrl_device_name);
applog(LOG_INFO, "%s: opened [%s] device", bitfury->drv->name, ctrl_device_name);
if (open_uart_device(UART_CHANNEL1) < 0)
quit(1, "%s: %s() failed to open [%s] device",
bitfury->drv->name, __func__, uart1_device_name);
applog(LOG_INFO, "%s: opened [%s] device", bitfury->drv->name, uart1_device_name);
if (open_uart_device(UART_CHANNEL2) < 0)
quit(1, "%s: %s() failed to open [%s] device",
bitfury->drv->name, __func__, uart2_device_name);
applog(LOG_INFO, "%s: opened [%s] device", bitfury->drv->name, uart2_device_name);
init_x5(bitfury);
/* send reset to boards */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
device_ctrl_transfer(board_id + 1, 1, F_BRST);
cgsleep_us(POWER_WAIT_INTERVAL);
device_ctrl_transfer(board_id + 1, 0, F_BRST);
cgsleep_us(POWER_WAIT_INTERVAL);
applog(LOG_INFO, "%s: sent reset to BOARD%d",
bitfury->drv->name, board_id + 1);
}
}
/* check if board power is present */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
/* read hw sensor data */
char buff[256];
if (info->chipboard[board_id].detected == true) {
memset(buff, 0, sizeof(buff));
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",
bitfury->drv->name);
/* disable board if power voltage is incorrect */
if ((info->chipboard[board_id].u_board < 10.0) ||
(info->chipboard[board_id].u_board > 15.0)) {
/* concentrator loop */
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
/* 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 */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
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 */
cgsleep_us(POWER_WAIT_INTERVAL);
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...",
bitfury->drv->name, __func__);
}
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);
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
/* 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",
bitfury->drv->name, __func__, board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d target temp to default value",
bitfury->drv->name, board_id + 1);
} else {
char uart_cmd[8];
sprintf(uart_cmd, "T:%d", opt_bf16_target_temp);
if (device_uart_transfer(board_id + 1, uart_cmd) < 0)
quit(1, "%s: %s() failed to set BOARD%d target temp",
bitfury->drv->name, __func__, board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d target temp to [%d]",
bitfury->drv->name, board_id + 1, 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",
bitfury->drv->name, __func__, board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d alarm temp to default value",
bitfury->drv->name, board_id + 1);
} else {
char uart_cmd[8];
sprintf(uart_cmd, "C:%d", opt_bf16_alarm_temp);
if (device_uart_transfer(board_id + 1, uart_cmd) < 0)
quit(1, "%s: %s() failed to set BOARD%d alarm temp",
bitfury->drv->name, __func__, board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d alarm temp to [%d]",
bitfury->drv->name, board_id + 1, opt_bf16_alarm_temp);
}
}
}
/* count number of renonce chips */
if (opt_bf16_renonce != RENONCE_DISABLED) {
info->renonce_chips = opt_bf16_renonce;
uint8_t renonce_chips = 0;
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
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 {
renonce_chip_address[board_id].board_id = -1;
renonce_chip_address[board_id].bcm250_id = -1;
renonce_chip_address[board_id].chip_id = -1;
}
}
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 {
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
renonce_chip_address[board_id].board_id = -1;
renonce_chip_address[board_id].bcm250_id = -1;
renonce_chip_address[board_id].chip_id = -1;
}
}
/* correct renonce chip address */
if (opt_bf16_renonce != RENONCE_DISABLED) {
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
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;
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
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_spi_device(SPI_CHANNEL2);
close_ctrl_device();
close_uart_device(UART_CHANNEL1);
close_uart_device(UART_CHANNEL2);
#ifdef FILELOG
fclose(info->logfile);
#endif
applog(LOG_ERR, "%s: no boards present. exiting...",
bitfury->drv->name);
free(info);
free(bitfury);
return;
}
mutex_init(&info->nonces_good_lock);
if (!add_cgpu(bitfury))
quit(1, "%s: %s() failed to add_cgpu",
bitfury->drv->name, __func__);
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;
uint8_t board_id = chip_address.board_id;
uint8_t bcm250_id = chip_address.bcm250_id;
uint8_t chip_id = chip_address.chip_id;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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,
board_id, bcm250_id, chip_id);
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,
board_id, bcm250_id, chip_id);
break;
/* fill chip buffer with set clock task */
case TOGGLE_SET:
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], prepare set_clock_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
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;
}
ret = cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth, chip_address, chip_address,
work, 0, CHIP_CMD_SET_CLOCK, 3, clock_buf);
if (ret < 0)
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d], error prepare set_clock_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
break;
/* fill chip buffer with chip mask */
case CLOCK_SET:
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], prepare set_mask_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
uint8_t noncemask[4];
memset(noncemask, 0, sizeof(noncemask));
for (i = 0; i < 4; i++)
noncemask[i] = (mask >> (8*(4 - i - 1))) & 0xff;
ret = cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth, chip_address, chip_address,
work, 0, CHIP_CMD_SET_MASK, 3, noncemask);
if (ret < 0)
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d], error prepare set_mask_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
break;
/* fill chip buffer with new task */
case MASK_SET:
if ((renonce_chip(chip_address) == 0) ||
(opt_bf16_renonce == RENONCE_DISABLED)) {
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], prepare send_task_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
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);
ret = cmd_buffer_push(cmd_buffer,
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,
board_id, bcm250_id, chip_id);
}
#if 0
else
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d], error prepare send_task_cmd: no works available",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
#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)) {
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], prepare task_status_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
ret = cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth, chip_address, chip_address,
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)
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d], error prepare task_status_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
}
break;
/* fill chip buffer with read nonces task */
case TASK_SWITCHED:
if ((renonce_chip(chip_address) == 0) ||
(opt_bf16_renonce == RENONCE_DISABLED)) {
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], prepare read_nonce_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
ret = cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth, chip_address, chip_address,
work, 0, CHIP_CMD_READ_NONCE, 0, NULL);
if (ret < 0)
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d], error prepare read_nonce_cmd",
bitfury->drv->name,
board_id, bcm250_id, chip_id);
}
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) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status = UNINITIALIZED;
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = curr_time_t;
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time, NULL);
}
} else {
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 = curr_time_t;
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++;
}
} else {
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 = curr_time_t;
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_time, NULL);
gettimeofday(&info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].switch_time, NULL);
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]",
board_id, bcm250_id, chip_id,
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]",
board_id, bcm250_id, chip_id,
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
}
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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
bf_cmd_buffer_t* cmd_buffer = &info->chipboard[board_id].cmd_buffer;
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:
case RENONCE_STAGE2:
/* 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 */
ret = cmd_buffer_push(cmd_buffer,
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;
case RENONCE_STAGE1:
case RENONCE_STAGE3:
/* 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 */
ret = cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth,
renonce_chip_address[board_id], 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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
bf_cmd_buffer_t* cmd_buffer = &info->chipboard[board_id].cmd_buffer;
bf_works_t work;
uint8_t i;
uint8_t bcm250_id = renonce_chip_address[board_id].bcm250_id;
uint8_t chip_id = renonce_chip_address[board_id].chip_id;
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,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth,
renonce_chip_address[board_id], renonce_chip_address[board_id],
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);
cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth,
renonce_chip_address[board_id], renonce_chip_address[board_id],
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;
cmd_buffer_push(cmd_buffer,
info->chipboard[board_id].bcm250[bcm250_id].channel_depth,
renonce_chip_address[board_id], renonce_chip_address[board_id],
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;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
bf_cmd_buffer_t* cmd_buffer = &info->chipboard[board_id].cmd_buffer;
/* concentrator loop */
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
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;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
bf_cmd_buffer_t* cmd_buffer = &info->chipboard[board_id].cmd_buffer;
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 {
L_LOCK(info->renonce_list);
bf_data_t* rdata = info->renonce_list->head;
while (rdata != NULL) {
if (RENONCE(rdata)->sent == false)
renonce_count++;
rdata = rdata->next;
}
L_UNLOCK(info->renonce_list);
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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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,
board_id, bcm250_id, chip_id,
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,
board_id, bcm250_id, chip_id,
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:
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], send_cmd [%s]",
bitfury->drv->name,
board_id, bcm250_id, chip_id,
get_cmd_description(cmd_status.cmd_code));
/* 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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].switch_time, NULL);
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 */
struct timeval curr_time;
gettimeofday(&curr_time, NULL);
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)) {
increase_errors(info, cmd_status.chip_address);
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,
board_id, bcm250_id, chip_id, 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]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
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
}
}
} 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,
board_id, bcm250_id, chip_id,
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_SWITCHED:
applog(LOG_DEBUG, "%s: chipworker_thr: chip [%d:%d:%2d], send_cmd [%s]",
bitfury->drv->name,
board_id, bcm250_id, chip_id,
get_cmd_description(cmd_status.cmd_code));
if (cmd_status.checksum_error == false) {
if ((renonce_chip(cmd_status.chip_address) == 1) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
/* 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 {
#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,
board_id, bcm250_id, chip_id,
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 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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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 curr_time = time(NULL);
time_t time_diff = curr_time - info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time;
if ((renonce_chip(cmd_status.chip_address) == 1) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
if ((time_diff >= RENONCE_CHIP_FAILING_INTERVAL) &&
(info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING)) {
increase_errors(info, cmd_status.chip_address);
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 = curr_time;
applog(LOG_ERR, "%s: nonceworker_thr: renonce chip [%d:%d:%2d] "
"failed: no good nonces during last [%.1f] seconds",
bitfury->drv->name,
board_id, bcm250_id, chip_id, 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]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
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
}
} else {
if ((time_diff >= CHIP_FAILING_INTERVAL) &&
(info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING)) {
increase_errors(info, cmd_status.chip_address);
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 = curr_time;
applog(LOG_ERR, "%s: nonceworker_thr: chip [%d:%d:%2d], "
"failed: no good nonces during last [%.1f] seconds",
bitfury->drv->name,
board_id, bcm250_id, chip_id, CHIP_FAILING_INTERVAL);
#ifdef FILELOG
filelog(info, "BF16: no good nonces from chip [%d:%d:%2d], "
"error count: [%d], recovery_count: [%d], error_rate: [%d]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
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
}
}
}
/* increase stage if no nonces received */
if ((renonce_chip(cmd_status.chip_address) == 1) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
L_LOCK(info->renonce_list);
bf_data_t* rdata = info->renonce_list->head;
while (rdata != NULL) {
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++;
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;
}
/* remove expired renonce */
if (RENONCE(rdata)->stage == RENONCE_STAGE_FINISHED) {
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;
}
}
RENONCE(rdata)->received = true;
break;
}
rdata = rdata->next;
}
L_UNLOCK(info->renonce_list);
}
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);
L_LOCK(info->renonce_list);
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
increase_re_bad_nonces(info, cmd_status.chip_address);
L_UNLOCK(info->renonce_list);
applog(LOG_DEBUG, "%s: chipworker_thr: pushing renonce task: nonce: [%08x]",
bitfury->drv->name,
found_nonces[i]);
continue;
}
/* add nonces to noncework list */
if ((renonce_chip(cmd_status.chip_address) == 1) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
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);
if ((renonce_chip(cmd_status.chip_address) == 1) &&
(opt_bf16_renonce != RENONCE_DISABLED)) {
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) {
#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,
board_id, bcm250_id, chip_id,
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);
}
if (cmd_status.nonce_checksum_error != 0) {
if ((renonce_chip(cmd_status.chip_address) == 0) ||
(opt_bf16_renonce == RENONCE_DISABLED)) {
applog(LOG_ERR, "%s: chipworker_thr: chip [%d:%d:%2d]: error receiving data. "
"nonce checksum: expected: [%02x]; received: [%02x]",
bitfury->drv->name,
board_id, bcm250_id, chip_id,
cmd_status.checksum_expected,
cmd_status.checksum_received);
/* increase error counters */
increase_errors(info, cmd_status.chip_address);
}
}
}
return 0;
}
/* routine sending-receiving data to chipboard */
static void process_cmd_buffer(struct cgpu_info *bitfury, uint8_t board_id)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
uint8_t i;
bf_cmd_status_t cmd_status;
bf_cmd_buffer_t* cmd_buffer = &info->chipboard[board_id].cmd_buffer;
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;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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 */
spi_emit_reset(SPI_CHANNEL1);
spi_emit_reset(SPI_CHANNEL2);
while (bitfury->shutdown == false) {
if ((info->a_temp == false) &&
(info->a_ichain == false)) {
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
/* 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
gettimeofday(&start_time, NULL);
/* send buffer to chipboard */
if (info->chipboard[board_id].cmd_buffer.status == TX_READY) {
spi_emit_reset(board_id + 1);
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;
}
gettimeofday(&stop_time, NULL);
#if 0
applog(LOG_ERR, "%s: chipworker_thr: board %d TX/RX time: [%.6f]",
bitfury->drv->name, board_id, timediff(start_time, stop_time));
#endif
gettimeofday(&start_time, NULL);
/* analyze received data */
if (info->chipboard[board_id].cmd_buffer.status == EXECUTED) {
process_cmd_buffer(bitfury, board_id);
}
gettimeofday(&stop_time, NULL);
#if 0
applog(LOG_ERR, "%s: chipworker_thr: board %d buffer processing: time elapsed: [%.6f]",
bitfury->drv->name, board_id, timediff(start_time, stop_time));
#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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
time_t curr_time = time(NULL);
uint16_t released = 0;
/* clear stale work list */
L_LOCK(info->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;
}
L_UNLOCK(info->stale_work_list);
applog(LOG_INFO, "%s: released %d works", bitfury->drv->name, released);
return released;
}
static void *bitfury_nonceworker(void *userdata)
{
struct cgpu_info *bitfury = (struct cgpu_info *)userdata;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
applog(LOG_INFO, "%s: started nonceworker thread", bitfury->drv->name);
while (bitfury->shutdown == false) {
if (info->initialised) {
break;
}
cgsleep_us(30);
}
applog(LOG_INFO, "%s: nonceworker loop started", bitfury->drv->name);
while (bitfury->shutdown == false) {
struct timeval start_time, stop_time;
gettimeofday(&start_time, NULL);
uint32_t nonce_cnt = 0;
/* general nonces processing */
L_LOCK(info->noncework_list);
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,
board_id, bcm250_id, chip_id, NONCEWORK(nwdata)->nonce);
submit_tested_work(info->thr, &NONCEWORK(nwdata)->owork.work);
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = time(NULL);
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count > 0) {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count = 0;
#ifdef FILELOG
filelog(info, "BF16: good nonce for chip [%d:%d:%2d] "
"setting recovery_count to [0], error_rate: [%d]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate);
#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,
board_id, bcm250_id, chip_id, NONCEWORK(nwdata)->nonce);
submit_tested_work(info->thr, &NONCEWORK(nwdata)->cwork.work);
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = time(NULL);
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count > 0) {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count = 0;
#ifdef FILELOG
filelog(info, "BF16: good nonce for chip [%d:%d:%2d] "
"setting recovery_count to 0, error_rate: [%d]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate);
#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 {
time_t curr_time = time(NULL);
time_t time_diff = curr_time - info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time;
if ((time_diff >= CHIP_FAILING_INTERVAL) &&
(info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING)) {
increase_errors(info, NONCEWORK(nwdata)->chip_address);
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 = curr_time;
applog(LOG_ERR, "%s: nonceworker_thr: chip [%d:%d:%2d], "
"failed: no good nonces during last [%.1f] seconds",
bitfury->drv->name,
board_id, bcm250_id, chip_id, CHIP_FAILING_INTERVAL);
#ifdef FILELOG
filelog(info, "BF16: no good nonces from chip [%d:%d:%2d], "
"error count: [%d], recovery_count: [%d], error_rate: [%d]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
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
}
if (opt_bf16_renonce != RENONCE_DISABLED) {
/* add failed nonce to renonce list */
increase_bad_nonces(info, NONCEWORK(nwdata)->chip_address);
L_LOCK(info->renonce_list);
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);
L_UNLOCK(info->renonce_list);
applog(LOG_DEBUG, "%s: nonceworker_thr: pushing renonce task: nonce: [%08x]",
bitfury->drv->name,
NONCEWORK(nwdata)->nonce);
} else
increase_bad_nonces(info, NONCEWORK(nwdata)->chip_address);
}
/* remove nonce from list */
noncework_list_pop(info->noncework_list);
nwdata = info->noncework_list->head;
}
L_UNLOCK(info->noncework_list);
/* cleanup older works */
cleanup_older(bitfury);
gettimeofday(&stop_time, NULL);
#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)
{
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
uint8_t board_id = RENONCEWORK(rnwdata)->src_address.board_id;
uint8_t bcm250_id = renonce_chip_address[board_id].bcm250_id;
uint8_t chip_id = renonce_chip_address[board_id].chip_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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = time(NULL);
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count > 0) {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count = 0;
#ifdef FILELOG
filelog(info, "BF16: good nonce for renonce chip [%d:%d:%2d] "
"setting recovery_count to 0, error_rate: [%d]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate);
#endif
}
increase_re_good_nonces(info, RENONCE(rdata)->src_address);
increase_re_good_nonces(info, renonce_chip_address[board_id]);
mutex_lock(&info->nonces_good_lock);
info->nonces_good_cg++;
mutex_unlock(&info->nonces_good_lock);
RENONCE(rdata)->match = true;
} else {
time_t curr_time = time(NULL);
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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING)) {
increase_errors(info, renonce_chip_address[board_id]);
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 = curr_time;
applog(LOG_ERR, "%s: nonceworker_thr: renonce chip [%d:%d:%2d] "
"failed: no good nonces during last [%.1f] seconds",
bitfury->drv->name,
board_id, bcm250_id, chip_id, 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]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
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
}
}
} 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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].last_nonce_time = time(NULL);
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count > 0) {
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].recovery_count = 0;
#ifdef FILELOG
filelog(info, "BF16: good nonce for renonce chip [%d:%d:%2d] "
"setting recovery_count to 0, error_rate: [%d]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].error_rate);
#endif
}
increase_re_good_nonces(info, RENONCE(rdata)->src_address);
increase_re_good_nonces(info, renonce_chip_address[board_id]);
mutex_lock(&info->nonces_good_lock);
info->nonces_good_cg++;
mutex_unlock(&info->nonces_good_lock);
RENONCE(rdata)->match = true;
} else {
time_t curr_time = time(NULL);
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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status < FAILING)) {
increase_errors(info, renonce_chip_address[board_id]);
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 = curr_time;
applog(LOG_ERR, "%s: nonceworker_thr: renonce chip [%d:%d:%2d] "
"failed: no good nonces during last [%.1f] seconds",
bitfury->drv->name,
board_id, bcm250_id, chip_id, 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]",
board_id, bcm250_id, chip_id,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].errors,
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
}
}
}
return RENONCE(rdata)->match;
}
static void *bitfury_renonceworker(void *userdata)
{
struct cgpu_info *bitfury = (struct cgpu_info *)userdata;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
bf_list_t* id_list = nonce_list_init();
applog(LOG_INFO, "%s: started renonceworker thread", bitfury->drv->name);
while (bitfury->shutdown == false) {
if (info->initialised) {
break;
}
cgsleep_us(30);
}
applog(LOG_INFO, "%s: renonceworker loop started", bitfury->drv->name);
while (bitfury->shutdown == false) {
struct timeval start_time, stop_time;
gettimeofday(&start_time, NULL);
uint32_t nonce_cnt = 0;
/* renonce chip results processing */
L_LOCK(info->renoncework_list);
bf_data_t* rnwdata = info->renoncework_list->head;
while (rnwdata != NULL) {
nonce_cnt++;
/* find nonce by id */
L_LOCK(info->renonce_list);
bf_data_t* rdata = info->renonce_list->head;
while (rdata != NULL) {
if (match_nonce(RENONCEWORK(rnwdata)->nonce, RENONCE(rdata)->nonce, mask_bits)) {
if (RENONCE(rdata)->match == false) {
switch (RENONCE(rdata)->stage) {
case RENONCE_STAGE0:
if (test_renonce(bitfury, rdata, rnwdata, true) == true)
info->stage0_match++;
else
info->stage0_mismatch++;
break;
case RENONCE_STAGE1:
case RENONCE_STAGE2:
case RENONCE_STAGE3:
/* test old work first */
if (test_renonce(bitfury, rdata, rnwdata, true) == true) {
if (RENONCE(rdata)->stage == RENONCE_STAGE1)
info->stage1_mismatch++;
if (RENONCE(rdata)->stage == RENONCE_STAGE2)
info->stage2_match++;
if (RENONCE(rdata)->stage == RENONCE_STAGE3)
info->stage3_mismatch++;
} else {
if (test_renonce(bitfury, rdata, rnwdata, false) == true) {
if (RENONCE(rdata)->stage == RENONCE_STAGE1)
info->stage1_match++;
if (RENONCE(rdata)->stage == RENONCE_STAGE2)
info->stage2_mismatch++;
if (RENONCE(rdata)->stage == RENONCE_STAGE3)
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;
}
rdata = rdata->next;
}
L_UNLOCK(info->renonce_list);
/* remove nonce from list */
renoncework_list_pop(info->renoncework_list);
rnwdata = info->renoncework_list->head;
}
L_UNLOCK(info->renoncework_list);
L_LOCK(info->renonce_list);
bf_data_t* rdata = info->renonce_list->head;
while (rdata != NULL) {
if (RENONCE(rdata)->match == true) {
bf_data_t* rndata = rdata->next;
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) {
RENONCE(rdata)->stage++;
RENONCE(rdata)->sent = false;
RENONCE(rdata)->received = false;
break;
}
ndata = ndata->next;
}
/* update tasks with wrong or dup nonces recieved */
if ((RENONCE(rdata)->stage != RENONCE_STAGE_FINISHED) &&
(RENONCE(rdata)->received == true)) {
RENONCE(rdata)->stage++;
RENONCE(rdata)->sent = false;
RENONCE(rdata)->received = 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++;
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_STAGE_FINISHED) &&
(RENONCE(rdata)->sent == false)) {
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;
}
rdata = rdata->next;
}
L_UNLOCK(info->renonce_list);
/* clear id list */
bf_data_t* ndata = id_list->head;
while (ndata != NULL) {
nonce_list_pop(id_list);
ndata = id_list->head;
}
gettimeofday(&stop_time, NULL);
#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)
{
struct cgpu_info *bitfury = (struct cgpu_info *)userdata;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
uint8_t board_id, bcm250_id, chip_id;
time_t curr_time;
applog(LOG_INFO, "%s: started hwmonitor thread", bitfury->drv->name);
while (bitfury->shutdown == false) {
if (info->initialised) {
break;
}
cgsleep_us(30);
}
applog(LOG_INFO, "%s: hwmonitor loop started", bitfury->drv->name);
while (bitfury->shutdown == false) {
float max_temp = 0.0;
float t_alarm = 100.0;
bool a_temp = false;
bool a_ichain = false;
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
/* read hw sensor data */
char buff[256];
if (info->chipboard[board_id].detected == true) {
memset(buff, 0, sizeof(buff));
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",
bitfury->drv->name);
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*/
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
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",
bitfury->drv->name, board_id + 1);
}
}
}
/* 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!!!",
bitfury->drv->name);
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",
bitfury->drv->name);
info->ialarm_count = 1;
info->ialarm_buzzer = false;
info->ialarm_start = time(NULL);
reinit_x5(info, false);
}
}
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 */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
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;
info->chipboard[board_id].power2_enable_time = curr_time;
#endif
}
}
} else if (opt_bf16_power_management_disabled == false) {
if (info->a_net == true) {
/* disable power chain if no internet available */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
#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;
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
#ifdef MINER_X5
if ((info->chipboard[board_id].p_chain1_enabled == 0) &&
(info->chipboard[board_id].power_disabled == false)) {
enable_power_chain(bitfury, board_id, 0);
info->chipboard[board_id].power_enable_time = time(NULL);
/* wait for power chain to enable */
cgsleep_us(POWER_WAIT_INTERVAL);
reinit_x5(info, false);
}
#endif
#ifdef MINER_X6
if ((info->chipboard[board_id].p_chain1_enabled == 0) &&
(info->chipboard[board_id].power1_disabled == false)){
enable_power_chain(bitfury, board_id, 1);
info->chipboard[board_id].power1_enable_time = time(NULL);
recovery = true;
}
if ((info->chipboard[board_id].p_chain2_enabled == 0) &&
(info->chipboard[board_id].power2_disabled == false)) {
enable_power_chain(bitfury, board_id, 2);
info->chipboard[board_id].power2_enable_time = time(NULL);
recovery = true;
}
#endif
}
}
/* reinit chips on alarm recovery */
if (recovery == true) {
/* wait for power chain to enable */
cgsleep_us(POWER_WAIT_INTERVAL);
reinit_x5(info, false);
}
}
}
/* board temperature regulation */
char uart_cmd[8];
if (manual_pid_enabled == false) {
sprintf(uart_cmd, "N:%d", (int)max_temp);
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
if (device_uart_transfer(board_id + 1, uart_cmd) < 0)
quit(1, "%s: %s() failed to set BOARD%d next temp",
bitfury->drv->name, __func__, board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d next temp to [%5.1f]",
bitfury->drv->name, board_id + 1, max_temp);
}
}
} else {
uint8_t max_fan_speed = 0;
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
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);
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
if (device_uart_transfer(board_id + 1, uart_cmd) < 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 [%d]",
bitfury->drv->name, board_id + 1, max_fan_speed);
}
}
}
/* board power management */
if (opt_bf16_power_management_disabled == false) {
curr_time = time(NULL);
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
#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++) {
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
/* chips loop */
for (chip_id = first_good_chip; chip_id < 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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status == DISABLED)
disabled_chips_chain1++;
}
if ((bcm250_id >= BCM250_NUM / 2) && (bcm250_id < BCM250_NUM)) {
total_chips_chain2++;
if (info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status == DISABLED)
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;
info->chipboard[board_id].chips_disabled = 0;
enable_power_chain(bitfury, board_id, 0);
info->chipboard[board_id].power_enable_time = curr_time;
info->chipboard[board_id].power_disabled = false;
/* wait for power chain to enable */
cgsleep_us(POWER_WAIT_INTERVAL);
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, (int)disable_interval);
#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) &&
(info->chipboard[board_id].p_chain1_enabled == 1) &&
(info->chipboard[board_id].power2_disabled == true)) {
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].power1_enable_time;
if (work_interval < CHAIN_WORK_INTERVAL)
info->chipboard[board_id].power1_disable_count *= 2;
info->chipboard[board_id].power1_disabled = true;
info->chipboard[board_id].power2_disabled = true;
info->chipboard[board_id].power1_disable_time = curr_time;
info->chipboard[board_id].power2_disable_time = curr_time;
info->chipboard[board_id].chips_disabled = info->chipboard[board_id].chips_num;
} else
if ((total_chips_chain2 == disabled_chips_chain2) &&
(info->chipboard[board_id].p_chain2_enabled == 1)) {
disable_power_chain(bitfury, board_id, 2);
/* increase disable counter until we reach long enough work time */
time_t work_interval = curr_time - info->chipboard[board_id].power2_enable_time;
if (work_interval < CHAIN_WORK_INTERVAL)
info->chipboard[board_id].power2_disable_count *= 2;
info->chipboard[board_id].power2_disabled = true;
info->chipboard[board_id].power2_disable_time = curr_time;
info->chipboard[board_id].chips_disabled = info->chipboard[board_id].chips_num / 2;
}
/* HW FIX: try to reenable disabled chain */
if ((info->chipboard[board_id].p_chain1_enabled == 0) &&
(info->chipboard[board_id].power1_disabled == true) &&
(curr_time - info->chipboard[board_id].power1_disable_time >= info->chipboard[board_id].power1_disable_count * CHAIN_REENABLE_INTERVAL)) {
time_t disable_interval = curr_time - info->chipboard[board_id].power1_disable_time;
info->chipboard[board_id].power1_disable_time = curr_time;
info->chipboard[board_id].power2_disable_time = curr_time;
info->chipboard[board_id].chips_disabled = 0;
enable_power_chain(bitfury, board_id, 0);
info->chipboard[board_id].power1_enable_time = curr_time;
info->chipboard[board_id].power2_enable_time = curr_time;
info->chipboard[board_id].power1_disabled = false;
info->chipboard[board_id].power2_disabled = false;
/* wait for power chain to enable */
cgsleep_us(POWER_WAIT_INTERVAL);
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, (int)disable_interval);
#endif
} else
if ((info->chipboard[board_id].p_chain2_enabled == 0) &&
(info->chipboard[board_id].power2_disabled == true) &&
(curr_time - info->chipboard[board_id].power2_disable_time >= info->chipboard[board_id].power2_disable_count * CHAIN_REENABLE_INTERVAL)) {
time_t disable_interval = curr_time - info->chipboard[board_id].power2_disable_time;
info->chipboard[board_id].power2_disable_time = curr_time;
info->chipboard[board_id].chips_disabled = 0;
enable_power_chain(bitfury, board_id, 2);
info->chipboard[board_id].power2_enable_time = curr_time;
info->chipboard[board_id].power2_disabled = false;
/* wait for power chain to enable */
cgsleep_us(POWER_WAIT_INTERVAL);
reinit_x5(info, true);
applog(LOG_NOTICE, "%s: reenabled chainboard 2 on BOARD%d: time interval [%d]",
bitfury->drv->name,
board_id + 1, (int)disable_interval);
#ifdef FILELOG
filelog(info, "%s: reenabled chainboard 2 on BOARD%d: time interval [%d]",
bitfury->drv->name,
board_id + 1, (int)disable_interval);
#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
(info->chipboard[board_id].power1_disabled == true) &&
(info->chipboard[board_id].power2_disabled == 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);
renonce_chip_address[board_id].board_id = -1;
renonce_chip_address[board_id].bcm250_id = -1;
renonce_chip_address[board_id].chip_id = -1;
}
}
}
}
cgsleep_us(HWMONITOR_DELAY);
}
applog(LOG_INFO, "%s: hwmonitor_thr: exiting...", bitfury->drv->name);
return NULL;
}
static void *bitfury_alarm(void *userdata)
{
struct cgpu_info *bitfury = (struct cgpu_info *)userdata;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
struct pool *pool;
int i;
time_t curr_time_t;
struct timeval curr_time;
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);
while (bitfury->shutdown == false) {
curr_time_t = time(NULL);
gettimeofday(&curr_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)
led_red_disable(info);
else
led_red_enable(info);
}
/* enable buzzer */
if (timediff_us(info->buzzer_switch, curr_time) >= BUZZER_INTERVAL) {
if (info->buzzer_enabled == true)
buzzer_disable(info);
else
buzzer_enable(info);
}
} else if ((info->a_ichain == false) && (info->a_net == false)) {
if (info->led_red_enabled == true)
led_red_disable(info);
if (info->buzzer_enabled == true)
buzzer_disable(info);
}
/* power chain alarm processing */
if ((info->a_ichain == true) && (info->a_temp == false)) {
if (timediff_us(info->led_red_switch, curr_time) >= LED_RED_INTERVAL) {
if (info->led_red_enabled == true)
led_red_disable(info);
else
led_red_enable(info);
}
if (info->ialarm_buzzer == false) {
buzzer_enable(info);
cgsleep_ms(1000);
buzzer_disable(info);
info->ialarm_buzzer = true;
}
/* enable buzzer */
if (curr_time_t - info->ialarm_start >= info->ialarm_count * ICHAIN_ALARM_INTERVAL) {
buzzer_enable(info);
cgsleep_ms(1000);
buzzer_disable(info);
}
} else if ((info->a_temp == false) && (info->a_net == false)) {
if (info->led_red_enabled == true)
led_red_disable(info);
if (info->buzzer_enabled == true)
buzzer_disable(info);
}
/* 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 (info->led_red_enabled == true)
led_red_disable(info);
if (timediff_us(info->led_green_switch, curr_time) >= LED_GREEN_INTERVAL) {
if (info->led_green_enabled == true)
led_green_disable(info);
else
led_green_enable(info);
}
} else {
if (info->led_green_enabled == true)
led_green_disable(info);
if ((info->a_temp == false) && (info->a_ichain == false)) {
if (timediff_us(info->led_red_switch, curr_time) >= LED_RED_NET_INTERVAL) {
if (info->led_red_enabled == true)
led_red_disable(info);
else
led_red_enable(info);
}
}
}
cgsleep_us(ALARM_DELAY);
}
led_red_disable(info);
led_green_disable(info);
buzzer_disable(info);
applog(LOG_INFO, "%s: alarm_thr: exiting...", bitfury->drv->name);
return NULL;
}
static void *bitfury_statistics(void *userdata)
{
struct cgpu_info *bitfury = (struct cgpu_info *)userdata;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->device_data);
struct timeval start_time, stop_time;
uint8_t board_id, bcm250_id, chip_id;
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 */
while (bitfury->shutdown == false) {
time2 = time(NULL);
if (time2 - time1 >= AVG_TIME_DELTA) {
gettimeofday(&start_time, NULL);
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;
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
info->chipboard[board_id].chips_failed = 0;
info->chips_disabled += info->chipboard[board_id].chips_disabled;
/* concentrator loop */
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
info->chipboard[board_id].bcm250[bcm250_id].chips_failed = 0;
/* chips loop */
for (chip_id = first_good_chip; chip_id < 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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
}
}
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_stats_enabled) {
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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_switch,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_none,
CHIP_COEFF * info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate,
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->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].task_switch,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].nonces,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd,
info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].status_cmd_none,
CHIP_COEFF * info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate,
CHIP_COEFF * info->chipboard[board_id].bcm250[bcm250_id].chips[chip_id].hashrate_good);
}
}
if (opt_bf16_stats_enabled) {
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,
(float)(time2 - time1), 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,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].bcm250[bcm250_id].nonces,
(float)info->chipboard[board_id].bcm250[bcm250_id].nonces_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].bcm250[bcm250_id].hashrate,
(float)info->chipboard[board_id].bcm250[bcm250_id].nonces_dx,
(float)(time2 - time1), 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,
(float)(time2 - time1), 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,
(float)(time2 - time1), 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,
(float)(time2 - time1), 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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
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 - time1), AVG_TIME_INTERVAL);
}
}
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;
if (opt_bf16_renonce != RENONCE_DISABLED) {
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;
}
}
if (opt_bf16_stats_enabled) {
get_average(&info->chipboard[board_id].task_switch,
(float)info->chipboard[board_id].task_switch_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].status_cmd,
(float)info->chipboard[board_id].status_cmd_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].status_cmd_none,
(float)info->chipboard[board_id].status_cmd_none_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].nonces,
(float)info->chipboard[board_id].nonces_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
}
get_average(&info->chipboard[board_id].hashrate,
(float)info->chipboard[board_id].nonces_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_good,
(float)info->chipboard[board_id].nonces_good_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_diff,
(float)info->chipboard[board_id].nonces_diff_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_bad,
(float)info->chipboard[board_id].nonces_bad_dx,
(float)(time2 - time1), 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;
if (opt_bf16_renonce != RENONCE_DISABLED) {
get_average(&info->chipboard[board_id].hashrate_re,
(float)info->chipboard[board_id].nonces_re_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_re_good,
(float)info->chipboard[board_id].nonces_re_good_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].hashrate_re_bad,
(float)info->chipboard[board_id].nonces_re_bad_dx,
(float)(time2 - time1), 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,
(float)(time2 - time1), AVG_TIME_INTERVAL);
info->chipboard[board_id].bytes_transmitted_dx = 0;
if (opt_bf16_stats_enabled) {
if (opt_bf16_renonce != RENONCE_DISABLED) {
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].u_chain1,
info->chipboard[board_id].u_chain2,
info->chipboard[board_id].i_chain1,
info->chipboard[board_id].i_chain2,
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);
}
}
}
if (opt_bf16_stats_enabled) {
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,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->status_cmd_none,
(float)info->status_cmd_none_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->chipboard[board_id].nonces,
(float)info->chipboard[board_id].nonces_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
}
get_average(&info->hashrate,
(float)info->nonces_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->hashrate_good,
(float)info->nonces_good_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->hashrate_diff,
(float)info->nonces_diff_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->hashrate_bad,
(float)info->nonces_bad_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
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;
if (opt_bf16_renonce != RENONCE_DISABLED) {
get_average(&info->hashrate_re,
(float)info->nonces_re_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->hashrate_re_good,
(float)info->nonces_re_good_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
get_average(&info->hashrate_re_bad,
(float)info->nonces_re_bad_dx,
(float)(time2 - time1), AVG_TIME_INTERVAL);
info->nonces_re_dx = 0;
info->nonces_re_good_dx = 0;
info->nonces_re_bad_dx = 0;
}
time1 = time2;
gettimeofday(&stop_time, NULL);
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;
if (opt_bf16_stats_enabled) {
if (opt_bf16_renonce != RENONCE_DISABLED) {
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->stage1_match / (time2 - time0),
info->stage1_mismatch / (time2 - time0),
info->stage2_match / (time2 - time0),
info->stage2_mismatch / (time2 - time0),
info->stage3_match / (time2 - time0),
info->stage3_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,
(info->a_net == true) ?
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_good / (info->chips_num - info->chips_failed),
CHIP_COEFF * info->hashrate_good / (info->chips_num - info->chips_failed),
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;
struct bitfury16_info *info = (struct bitfury16_info *)(bitfury->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",
bitfury->drv->name, __func__);
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",
bitfury->drv->name, __func__);
return false;
}
pthread_detach(info->nonceworker_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting nonceworker thread", bitfury->drv->name);
if (opt_bf16_renonce != RENONCE_DISABLED) {
if (thr_info_create(&(info->renonceworker_thr), NULL, bitfury_renonceworker, (void *)bitfury)) {
applog(LOG_ERR, "%s: %s() renonceworker thread create failed",
bitfury->drv->name, __func__);
return false;
}
pthread_detach(info->renonceworker_thr.pth);
applog(LOG_INFO, "%s: thread prepare: starting renonceworker thread", bitfury->drv->name);
}
if (thr_info_create(&(info->hwmonitor_thr), NULL, bitfury_hwmonitor, (void *)bitfury)) {
applog(LOG_ERR, "%s: %s() hwmonitor thread create failed",
bitfury->drv->name, __func__);
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",
bitfury->drv->name, __func__);
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",
bitfury->drv->name, __func__);
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 cgpu_info *bitfury = thr->cgpu;
struct bitfury16_info *info = bitfury->device_data;
int64_t hashcount = 0;
applog(LOG_INFO, "%s: scan work", bitfury->drv->name);
mutex_lock(&info->nonces_good_lock);
if (info->nonces_good_cg) {
hashcount += 0xffffffffull * info->nonces_good_cg;
info->nonces_good_cg = 0;
}
mutex_unlock(&info->nonces_good_lock);
return hashcount;
}
static void prepare_work(struct cgpu_info *bitfury, struct work *work, bool rolled)
{
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
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 bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
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;
}
L_LOCK(info->work_list);
uint16_t work_count = info->work_list->count;
L_UNLOCK(info->work_list);
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;
L_LOCK(info->work_list);
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));
L_UNLOCK(info->work_list);
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)
{
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
uint16_t flushed = 0;
if (info->initialised == false)
return;
bf_works_t works;
/* flush work list */
L_LOCK(info->work_list);
L_LOCK(info->stale_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++;
}
L_UNLOCK(info->stale_work_list);
L_UNLOCK(info->work_list);
/* flush nonces list */
L_LOCK(info->noncework_list);
bf_data_t* nwdata = info->noncework_list->head;
while (nwdata != NULL) {
noncework_list_pop(info->noncework_list);
nwdata = info->noncework_list->head;
}
L_UNLOCK(info->noncework_list);
if (opt_bf16_renonce != RENONCE_DISABLED) {
/* flush renonces list */
L_LOCK(info->renonce_list);
bf_data_t* rdata = info->renonce_list->head;
while (rdata != NULL) {
renonce_list_pop(info->renonce_list);
rdata = info->renonce_list->head;
}
L_UNLOCK(info->renonce_list);
/* flush renoncework list */
L_LOCK(info->renoncework_list);
bf_data_t* rnwdata = info->renoncework_list->head;
while (rnwdata != NULL) {
renoncework_list_pop(info->renoncework_list);
rnwdata = info->renoncework_list->head;
}
L_UNLOCK(info->renoncework_list);
}
applog(LOG_INFO, "%s: flushed %d works", bitfury->drv->name, flushed);
}
static struct api_data *bitfury16_api_stats(struct cgpu_info *bitfury)
{
uint8_t board_id, bcm250_id, chip_id;
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);
root = api_add_string(root, "hwv2", "2", true);
root = api_add_string(root, "hwv3", "11", true);
root = api_add_string(root, "hwv4", "0", true);
root = api_add_string(root, "hwv5", "0", 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);
if (opt_bf16_renonce != RENONCE_DISABLED) {
/* Efficiency */
sprintf(value, "%.3f",
(info->a_net == true) ?
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->chips_num - info->renonce_chips - info->chips_failed));
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->chips_num - info->renonce_chips - info->chips_failed));
root = api_add_string(root, "Chip GHS bad avg", value, true);
} else {
/* Efficiency */
sprintf(value, "%.3f",
(info->a_net == true) ?
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 */
sprintf(value, "%.1f", CHIP_COEFF * info->hashrate_good / (info->chips_num - 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->chips_failed));
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->chips_num - info->chips_failed));
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);
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
/* 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);
if (opt_bf16_renonce != RENONCE_DISABLED) {
sprintf(value, "%.2f",
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));
}
root = api_add_string(root, data, value, true);
/* number of chips per concentrator */
uint8_t i = 0;
memset(value, 0, sizeof(value));
for (bcm250_id = 0; bcm250_id < BCM250_NUM; bcm250_id++) {
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);
uint8_t first_good_chip = info->chipboard[board_id].bcm250[bcm250_id].first_good_chip;
uint8_t last_good_chip = info->chipboard[board_id].bcm250[bcm250_id].last_good_chip;
/* chips loop */
for (chip_id = first_good_chip; chip_id < last_good_chip; 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) {
if ((opt_bf16_renonce != RENONCE_DISABLED) &&
(renonce_chip(chip_address) == 1))
value[i] = 'O';
else
value[i] = 'o';
} else {
if ((opt_bf16_renonce != RENONCE_DISABLED) &&
(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);
root = api_add_string(root, data, value, true);
/* 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);
root = api_add_uint32(root, data, &info->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);
root = api_add_string(root, data, value, true);
/* UB */
sprintf(data, "Board%d UB", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].u_board);
root = api_add_string(root, data, value, true);
/* P1 */
sprintf(data, "Board%d P1", board_id);
root = api_add_uint8(root, data, &info->chipboard[board_id].p_chain1_enabled, false);
/* P2 */
sprintf(data, "Board%d P2", board_id);
root = api_add_uint8(root, data, &info->chipboard[board_id].p_chain2_enabled, false);
/* U1 */
sprintf(data, "Board%d U1", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].u_chain1);
root = api_add_string(root, data, value, true);
/* U2 */
sprintf(data, "Board%d U2", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].u_chain2);
root = api_add_string(root, data, value, true);
/* I1 */
sprintf(data, "Board%d I1", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].i_chain1);
root = api_add_string(root, data, value, true);
/* I2 */
sprintf(data, "Board%d I2", board_id);
sprintf(value, "%.1f", info->chipboard[board_id].i_chain2);
root = api_add_string(root, data, value, true);
/* 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);
root = api_add_string(root, data, value, true);
/* AT */
sprintf(data, "Board%d AT", board_id);
sprintf(value, "%.0f", info->chipboard[board_id].t_alarm);
root = api_add_string(root, data, value, true);
/* AG */
sprintf(data, "Board%d AG", board_id);
sprintf(value, "%.0f", info->chipboard[board_id].t_gisteresis);
root = api_add_string(root, data, value, true);
/* 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
root = api_add_string(root, data, value, true);
/* TT */
sprintf(data, "Board%d TT", board_id);
sprintf(value, "%.0f", info->chipboard[board_id].target_temp);
root = api_add_string(root, data, value, true);
}
return root;
}
static void bitfury16_shutdown(struct thr_info *thr)
{
struct cgpu_info *bitfury = thr->cgpu;
struct bitfury16_info *info = (struct bitfury16_info *)bitfury->device_data;
uint8_t board_id;
bitfury->shutdown = true;
cgsleep_ms(300);
/* flush next board temp to default value */
if (manual_pid_enabled == false) {
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
if (device_uart_transfer(board_id + 1, "N") < 0)
quit(1, "%s: %s() failed to set BOARD%d next temp",
bitfury->drv->name, __func__, board_id + 1);
applog(LOG_INFO, "%s: set BOARD%d next temp to default value",
bitfury->drv->name, board_id + 1);
}
}
} else {
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
if (info->chipboard[board_id].detected == true) {
if (device_uart_transfer(board_id + 1, "F") < 0)
quit(1, "%s: %s() failed to set BOARD%d fan speed to auto mode",
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);
}
}
}
/* disable power chain */
for (board_id = 0; board_id < CHIPBOARD_NUM; board_id++) {
disable_power_chain(bitfury, board_id, 0);
}
mutex_destroy(&info->nonces_good_lock);
/* close devices */
close_spi_device(SPI_CHANNEL1);
close_spi_device(SPI_CHANNEL2);
close_ctrl_device();
close_uart_device(UART_CHANNEL1);
close_uart_device(UART_CHANNEL2);
#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
};
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。