static void spond_drop_job(struct spond_adapter *device, uint32_t job_id_index)
{
cg_wlock(&(device->my_jobs[job_id_index].data_lock));
if (device->my_jobs[job_id_index].pool.swork.job_id != NULL) {
SPONDLOG(LOG_INFO, "discard previous job[%d] pool.swork.job_id[%s]\n",
device->my_jobs[job_id_index].sw_job_id,
device->my_jobs[job_id_index].pool.swork.job_id);
free_pool_stratum(device, job_id_index);
}
cg_wunlock(&(device->my_jobs[job_id_index].data_lock));
}
static void copy_pool_stratum(struct pool *pool)
{
int i;
int merkles = pool->merkles;
size_t coinbase_len = pool->coinbase_len;
if (!job_idcmp(pool->swork.job_id, pool_stratum.swork.job_id))
return;
cg_wlock(&(pool_stratum.data_lock));
free(pool_stratum.swork.job_id);
free(pool_stratum.nonce1);
free(pool_stratum.coinbase);
align_len(&coinbase_len);
pool_stratum.coinbase = calloc(coinbase_len, 1);
if (unlikely(!pool_stratum.coinbase))
quit(1, "Failed to calloc pool_stratum coinbase in avalon2");
memcpy(pool_stratum.coinbase, pool->coinbase, coinbase_len);
for (i = 0; i < pool_stratum.merkles; i++)
free(pool_stratum.swork.merkle_bin[i]);
if (merkles) {
pool_stratum.swork.merkle_bin = realloc(pool_stratum.swork.merkle_bin,
sizeof(char *) * merkles + 1);
for (i = 0; i < merkles; i++) {
pool_stratum.swork.merkle_bin[i] = malloc(32);
if (unlikely(!pool_stratum.swork.merkle_bin[i]))
quit(1, "Failed to malloc pool_stratum swork merkle_bin");
memcpy(pool_stratum.swork.merkle_bin[i], pool->swork.merkle_bin[i], 32);
}
}
pool_stratum.sdiff = pool->sdiff;
pool_stratum.coinbase_len = pool->coinbase_len;
pool_stratum.nonce2_offset = pool->nonce2_offset;
pool_stratum.n2size = pool->n2size;
pool_stratum.merkles = pool->merkles;
pool_stratum.swork.job_id = strdup(pool->swork.job_id);
pool_stratum.nonce1 = strdup(pool->nonce1);
memcpy(pool_stratum.ntime, pool->ntime, sizeof(pool_stratum.ntime));
memcpy(pool_stratum.header_bin, pool->header_bin, sizeof(pool_stratum.header_bin));
cg_wunlock(&(pool_stratum.data_lock));
}
static void copy_pool_stratum(struct spond_adapter* spond, struct pool *pool)
{
int i;
int merkles = pool->merkles;
size_t coinbase_len = pool->coinbase_len;
struct pool *pool_stratum = &spond->my_jobs[get_array_id(spond->current_job_id)].pool;
if (pool_stratum->swork.job_id != NULL) {
spond_drop_job(spond, get_array_id(spond->current_job_id));
SPONDLOG(LOG_DEBUG, "discarding pool->swork.job_id[%s], sw_job_id[%d]",
pool_stratum->swork.job_id, spond->my_jobs[get_array_id(spond->current_job_id)].sw_job_id);
}
cg_wlock(&(spond->my_jobs[get_array_id(spond->current_job_id)].data_lock));
// lets write down sw job id
spond->my_jobs[get_array_id(spond->current_job_id)].sw_job_id = spond->current_job_id;
free_pool_stratum(spond, get_array_id(spond->current_job_id));
pool_stratum->coinbase = cgcalloc(coinbase_len, 1);
memcpy(pool_stratum->coinbase, pool->coinbase, coinbase_len);
for (i = 0; i < pool_stratum->merkles; i++)
free(pool_stratum->swork.merkle_bin[i]);
if (merkles) {
pool_stratum->swork.merkle_bin = cgrealloc(pool_stratum->swork.merkle_bin,
sizeof(char *) * merkles + 1);
for (i = 0; i < merkles; i++) {
pool_stratum->swork.merkle_bin[i] = cgmalloc(32);
memcpy(pool_stratum->swork.merkle_bin[i], pool->swork.merkle_bin[i], 32);
}
}
pool_stratum->sdiff = pool->sdiff;
pool_stratum->coinbase_len = pool->coinbase_len;
pool_stratum->nonce2_offset = pool->nonce2_offset;
pool_stratum->n2size = pool->n2size;
pool_stratum->merkles = pool->merkles;
pool_stratum->swork.job_id = strdup(pool->swork.job_id);
pool_stratum->nonce1 = strdup(pool->nonce1);
memcpy(pool_stratum->ntime, pool->ntime, sizeof(pool_stratum->ntime));
memcpy(pool_stratum->header_bin, pool->header_bin, sizeof(pool_stratum->header_bin));
cg_wunlock(&(spond->my_jobs[get_array_id(spond->current_job_id)].data_lock));
}
static void copy_pool_stratum(struct hashratio_info *info, struct pool *pool)
{
int i;
int merkles = pool->merkles;
size_t coinbase_len = pool->coinbase_len;
struct pool *pool_stratum = &info->pool;
if (!job_idcmp((uint8_t *)pool->swork.job_id, pool_stratum->swork.job_id))
return;
cg_wlock(&(pool_stratum->data_lock));
free(pool_stratum->swork.job_id);
free(pool_stratum->nonce1);
free(pool_stratum->coinbase);
pool_stratum->coinbase = cgcalloc(coinbase_len, 1);
memcpy(pool_stratum->coinbase, pool->coinbase, coinbase_len);
for (i = 0; i < pool_stratum->merkles; i++)
free(pool_stratum->swork.merkle_bin[i]);
if (merkles) {
pool_stratum->swork.merkle_bin = cgrealloc(pool_stratum->swork.merkle_bin,
sizeof(char *) * merkles + 1);
for (i = 0; i < merkles; i++) {
pool_stratum->swork.merkle_bin[i] = cgmalloc(32);
memcpy(pool_stratum->swork.merkle_bin[i], pool->swork.merkle_bin[i], 32);
}
}
pool_stratum->sdiff = pool->sdiff;
pool_stratum->coinbase_len = pool->coinbase_len;
pool_stratum->nonce2_offset = pool->nonce2_offset;
pool_stratum->n2size = pool->n2size;
pool_stratum->merkles = pool->merkles;
pool_stratum->swork.job_id = strdup(pool->swork.job_id);
pool_stratum->nonce1 = strdup(pool->nonce1);
memcpy(pool_stratum->ntime, pool->ntime, sizeof(pool_stratum->ntime));
memcpy(pool_stratum->header_bin, pool->header_bin, sizeof(pool_stratum->header_bin));
cg_wunlock(&(pool_stratum->data_lock));
}
static int64_t avalon2_scanhash(struct thr_info *thr)
{
struct avalon2_pkg send_pkg;
struct pool *pool;
struct cgpu_info *avalon2 = thr->cgpu;
struct avalon2_info *info = avalon2->device_data;
int64_t h;
uint32_t tmp, range, start;
int i;
if (thr->work_restart || thr->work_update ||
info->first) {
info->new_stratum = true;
applog(LOG_DEBUG, "Avalon2: New stratum: restart: %d, update: %d, first: %d",
thr->work_restart, thr->work_update, info->first);
thr->work_update = false;
thr->work_restart = false;
if (unlikely(info->first))
info->first = false;
get_work(thr, thr->id); /* Make sure pool is ready */
pool = current_pool();
if (!pool->has_stratum)
quit(1, "Avalon2: Miner Manager have to use stratum pool");
if (pool->swork.cb_len > AVA2_P_COINBASE_SIZE)
quit(1, "Avalon2: Miner Manager pool coinbase length have to less then %d", AVA2_P_COINBASE_SIZE);
if (pool->swork.merkles > AVA2_P_MERKLES_COUNT)
quit(1, "Avalon2: Miner Manager merkles have to less then %d", AVA2_P_MERKLES_COUNT);
info->diff = (int)pool->swork.diff - 1;
info->pool_no = pool->pool_no;
cg_wlock(&pool->data_lock);
avalon2_stratum_pkgs(info->fd, pool, thr);
cg_wunlock(&pool->data_lock);
/* Configuer the parameter from outside */
info->fan_pwm = opt_avalon2_fan_min;
info->set_voltage = opt_avalon2_voltage_min;
info->set_frequency = opt_avalon2_freq_min;
/* Set the Fan, Voltage and Frequency */
memset(send_pkg.data, 0, AVA2_P_DATA_LEN);
tmp = be32toh(info->fan_pwm);
memcpy(send_pkg.data, &tmp, 4);
tmp = encode_voltage(info->set_voltage);
tmp = be32toh(tmp);
memcpy(send_pkg.data + 4, &tmp, 4);
tmp = be32toh(info->set_frequency);
memcpy(send_pkg.data + 8, &tmp, 4);
/* Configure the nonce2 offset and range */
range = 0xffffffff / total_devices;
start = range * avalon2->device_id;
tmp = be32toh(start);
memcpy(send_pkg.data + 12, &tmp, 4);
tmp = be32toh(range);
memcpy(send_pkg.data + 16, &tmp, 4);
/* Package the data */
avalon2_init_pkg(&send_pkg, AVA2_P_SET, 1, 1);
while (avalon2_send_pkg(info->fd, &send_pkg, thr) != AVA2_SEND_OK)
;
info->new_stratum = false;
}
polling(thr);
h = 0;
for (i = 0; i < AVA2_DEFAULT_MODULARS; i++) {
h += info->local_work[i];
}
return h * 0xffffffff;
}
static int64_t hashratio_scanhash(struct thr_info *thr)
{
struct hashratio_pkg send_pkg;
struct pool *pool;
struct cgpu_info *hashratio = thr->cgpu;
struct hashratio_info *info = hashratio->device_data;
struct hashratio_ret ret_pkg;
uint32_t tmp, range, start;
int i;
if (thr->work_restart || thr->work_update || info->first) {
info->new_stratum = true;
applog(LOG_DEBUG, "hashratio: New stratum: restart: %d, update: %d, first: %d",
thr->work_restart, thr->work_update, info->first);
thr->work_update = false;
thr->work_restart = false;
if (unlikely(info->first))
info->first = false;
get_work(thr, thr->id); /* Make sure pool is ready */
pool = current_pool();
if (!pool->has_stratum)
quit(1, "hashratio: Miner Manager have to use stratum pool");
if (pool->coinbase_len > HRTO_P_COINBASE_SIZE)
quit(1, "hashratio: Miner Manager pool coinbase length have to less then %d", HRTO_P_COINBASE_SIZE);
if (pool->merkles > HRTO_P_MERKLES_COUNT)
quit(1, "hashratio: Miner Manager merkles have to less then %d", HRTO_P_MERKLES_COUNT);
info->diff = (int)pool->swork.diff - 1;
info->pool_no = pool->pool_no;
cg_wlock(&pool->data_lock);
hashratio_stratum_pkgs(info->fd, pool, thr);
cg_wunlock(&pool->data_lock);
/* Configuer the parameter from outside */
memset(send_pkg.data, 0, HRTO_P_DATA_LEN);
// fan
info->fan_pwm = HRTO_PWM_MAX;
tmp = be32toh(info->fan_pwm);
memcpy(send_pkg.data, &tmp, 4);
// freq
tmp = be32toh(info->default_freq);
memcpy(send_pkg.data + 4, &tmp, 4);
applog(LOG_DEBUG, "set freq: %d", info->default_freq);
/* Configure the nonce2 offset and range */
range = 0xffffffff / total_devices;
start = range * hashratio->device_id;
tmp = be32toh(start);
memcpy(send_pkg.data + 8, &tmp, 4);
tmp = be32toh(range);
memcpy(send_pkg.data + 12, &tmp, 4);
/* Package the data */
hashratio_init_pkg(&send_pkg, HRTO_P_SET, 1, 1);
while (hashratio_send_pkg(info->fd, &send_pkg, thr) != HRTO_SEND_OK)
;
info->new_stratum = false;
}
polling(thr);
return (int64_t)info->local_work * 64 * 0xffffffff;
}
