0% found this document useful (0 votes)

77 views95 pages

Driver Bitfury16

This document contains C header code for configuring and initializing a Bitfury mining board driver. It defines various constants for settings like timeouts, thresholds, and intervals. It also declares structures for PID settings, chip mappings, and other configuration options. Logging and timing functions are implemented to support the driver operations.

Uploaded by

alexandr

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

77 views95 pages

Driver Bitfury16

Uploaded by

alexandr

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

You are on page 1/ 95

#include "config.

#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;
}
}