/* * Copyright 2016 Mikeqin * Copyright 2016 Con Kolivas * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 3 of the License, or (at your option) * any later version. See COPYING for more details. */ #include #include "config.h" #include "miner.h" #include "driver-avalon7.h" #include "crc.h" #include "sha2.h" #include "hexdump.c" #define get_fan_pwm(v) (AVA7_PWM_MAX - (v) * AVA7_PWM_MAX / 100) int opt_avalon7_temp_target = AVA7_DEFAULT_TEMP_TARGET; int opt_avalon7_fan_min = AVA7_DEFAULT_FAN_MIN; int opt_avalon7_fan_max = AVA7_DEFAULT_FAN_MAX; int opt_avalon7_voltage = AVA7_INVALID_VOLTAGE; int opt_avalon7_voltage_offset = AVA7_DEFAULT_VOLTAGE_OFFSET; int opt_avalon7_freq[AVA7_DEFAULT_PLL_CNT] = {AVA7_DEFAULT_FREQUENCY_0, AVA7_DEFAULT_FREQUENCY_1, AVA7_DEFAULT_FREQUENCY_2, AVA7_DEFAULT_FREQUENCY_3, AVA7_DEFAULT_FREQUENCY_4, AVA7_DEFAULT_FREQUENCY_5}; int opt_avalon7_freq_sel = AVA7_DEFAULT_FREQUENCY_SEL; int opt_avalon7_polling_delay = AVA7_DEFAULT_POLLING_DELAY; int opt_avalon7_aucspeed = AVA7_AUC_SPEED; int opt_avalon7_aucxdelay = AVA7_AUC_XDELAY; int opt_avalon7_smart_speed = AVA7_DEFAULT_SMART_SPEED; /* * smart speed have 2 modes * 1. auto speed by A3212 chips * 2. option 1 + adjust by average frequency */ bool opt_avalon7_iic_detect = AVA7_DEFAULT_IIC_DETECT; uint32_t opt_avalon7_th_pass = AVA7_DEFAULT_TH_PASS; uint32_t opt_avalon7_th_fail = AVA7_DEFAULT_TH_FAIL; uint32_t opt_avalon7_th_init = AVA7_DEFAULT_TH_INIT; uint32_t opt_avalon7_th_ms = AVA7_DEFAULT_TH_MS; uint32_t opt_avalon7_th_timeout = AVA7_DEFAULT_TH_TIMEOUT; uint32_t opt_avalon7_nonce_mask = AVA7_DEFAULT_NONCE_MASK; bool opt_avalon7_asic_debug = true; uint32_t cpm_table[] = { 0x0173f813, 0x0175f813, 0x0163f813, 0x0164f813, 0x0165f813, 0x0166f813, 0x0153f813, 0x01547813, 0x0154f813, 0x01557813, 0x0155f813, 0x01567813, 0x0156f813, 0x01577813, 0x0143f813, 0x01443813, 0x01447813, 0x0144b813, 0x0144f813, 0x01453813, 0x01457813, 0x0145b813, 0x0145f813, 0x01463813, 0x01467813, 0x0146b813, 0x0146f813, 0x01473813, 0x01477813, 0x0147b813, 0x0133f813, 0x01341813, 0x01343813, 0x01345813, 0x01347813, 0x01349813, 0x0134b813, 0x0134d813, 0x0134f813, 0x01351813, 0x01353813, 0x01355813, 0x01357813, 0x01359813, 0x0135b813, 0x0135d813, 0x0135f813, 0x01361813, 0x01363813, 0x01365813, 0x01367813, 0x01369813, 0x0136b813, 0x0136d813, 0x0136f813, 0x01371813, 0x01373813, 0x01375813, 0x01377813, 0x01379813, 0x0137b813, 0x0123e813, 0x0123f813, 0x01240813, 0x01241813, 0x01242813, 0x01243813, 0x01244813, 0x01245813, 0x01246813, 0x01247813, 0x01248813, 0x01249813, 0x0124a813, 0x0124b813, 0x0124c813, 0x0124d813, 0x0124e813, 0x0124f813, 0x01250813, 0x01251813, 0x01252813, 0x01253813, 0x01254813, 0x01255813, 0x01256813, 0x01257813, 0x01258813, 0x01259813, 0x0125a813, 0x0125b813, 0x0125c813, 0x0125d813, 0x0125e813, 0x0125f813, 0x01260813, 0x01261813, 0x01262813, 0x01263813, 0x01264813, 0x01265813, 0x01266813, 0x01267813, 0x01268813, 0x01269813, 0x0126a813, 0x0126b813, 0x0126c813, 0x0126d813, 0x0126e813, 0x0126f813, 0x01270813, 0x01271813, 0x01272813, 0x01273813, 0x01274813, }; struct avalon7_dev_description avalon7_dev_table[] = { { "711", 711, 4, 18, AVA7_MM711_VIN_ADC_RATIO, AVA7_MM711_VOUT_ADC_RATIO, 4981 }, { "721", 721, 4, 18, AVA7_MM721_VIN_ADC_RATIO, AVA7_MM721_VOUT_ADC_RATIO, 4981 }, { "741", 741, 4, 22, AVA7_MM741_VIN_ADC_RATIO, AVA7_MM741_VOUT_ADC_RATIO, 4825, }, { "761", 761, 4, 26, AVA7_MM761_VIN_ADC_RATIO, AVA7_MM761_VOUT_ADC_RATIO, 4825, } }; static uint32_t api_get_cpm(uint32_t freq) { return cpm_table[freq / 12 - 2]; } static uint32_t encode_voltage(uint32_t volt) { if (volt > AVA7_DEFAULT_VOLTAGE_MAX) volt = AVA7_DEFAULT_VOLTAGE_MAX; if (volt < AVA7_DEFAULT_VOLTAGE_MIN) volt = AVA7_DEFAULT_VOLTAGE_MIN; return 0x8000 | ((volt - AVA7_DEFAULT_VOLTAGE_MIN) / AVA7_DEFAULT_VOLTAGE_STEP); } static uint32_t convert_voltage_level(uint32_t level) { if (level > AVA7_DEFAULT_VOLTAGE_LEVEL_MAX) level = AVA7_DEFAULT_VOLTAGE_LEVEL_MAX; return AVA7_DEFAULT_VOLTAGE_MIN + level * AVA7_DEFAULT_VOLTAGE_STEP; } static uint32_t decode_voltage(struct avalon7_info *info, int modular_id, uint32_t volt) { return (volt * info->vout_adc_ratio[modular_id] / info->asic_count[modular_id] / 100); } static uint16_t decode_vin(struct avalon7_info *info, int modular_id, uint16_t volt) { return (volt * info->vin_adc_ratio[modular_id] / 1000); } static double decode_pvt_temp(uint16_t pvt_code) { double a4 = -1.1876E-11; double a3 = 6.6675E-08; double a2 = -1.7724E-04; double a1 = 3.3691E-01; double a0 = -6.0605E+01; return a4 * pow(pvt_code, 4) + a3 * pow(pvt_code, 3) + a2 * pow(pvt_code, 2) + a1 * pow(pvt_code, 1) + a0; } #define SERIESRESISTOR 10000 #define THERMISTORNOMINAL 10000 #define BCOEFFICIENT 3500 #define TEMPERATURENOMINAL 25 float decode_auc_temp(int value) { float ret, resistance; if (!((value > 0) && (value < 33000))) return -273; resistance = (3.3 * 10000 / value) - 1; resistance = SERIESRESISTOR / resistance; ret = resistance / THERMISTORNOMINAL; ret = logf(ret); ret /= BCOEFFICIENT; ret += 1.0 / (TEMPERATURENOMINAL + 273.15); ret = 1.0 / ret; ret -= 273.15; return ret; } #define UNPACK32(x, str) \ { \ *((str) + 3) = (uint8_t) ((x) ); \ *((str) + 2) = (uint8_t) ((x) >> 8); \ *((str) + 1) = (uint8_t) ((x) >> 16); \ *((str) + 0) = (uint8_t) ((x) >> 24); \ } static inline void sha256_prehash(const unsigned char *message, unsigned int len, unsigned char *digest) { int i; sha256_ctx ctx; sha256_init(&ctx); sha256_update(&ctx, message, len); for (i = 0; i < 8; i++) UNPACK32(ctx.h[i], &digest[i << 2]); } char *set_avalon7_fan(char *arg) { int val1, val2, ret; ret = sscanf(arg, "%d-%d", &val1, &val2); if (ret < 1) return "No value passed to avalon7-fan"; if (ret == 1) val2 = val1; if (val1 < 0 || val1 > 100 || val2 < 0 || val2 > 100 || val2 < val1) return "Invalid value passed to avalon7-fan"; opt_avalon7_fan_min = val1; opt_avalon7_fan_max = val2; return NULL; } char *set_avalon7_freq(char *arg) { int val[AVA7_DEFAULT_PLL_CNT]; char *colon, *data; int i; if (!(*arg)) return NULL; data = arg; memset(val, 0, sizeof(val)); for (i = 0; i < AVA7_DEFAULT_PLL_CNT; i++) { colon = strchr(data, ':'); if (colon) *(colon++) = '\0'; else { /* last value */ if (*data) { val[i] = atoi(data); if (val[i] < AVA7_DEFAULT_FREQUENCY_MIN || val[i] > AVA7_DEFAULT_FREQUENCY_MAX) return "Invalid value passed to avalon7-freq"; } break; } if (*data) { val[i] = atoi(data); if (val[i] < AVA7_DEFAULT_FREQUENCY_MIN || val[i] > AVA7_DEFAULT_FREQUENCY_MAX) return "Invalid value passed to avalon7-freq"; } data = colon; } for (i = 0; i < AVA7_DEFAULT_PLL_CNT; i++) { if (!val[i] && i) val[i] = val[i - 1]; opt_avalon7_freq[i] = val[i]; } return NULL; } char *set_avalon7_voltage(char *arg) { int val, ret; ret = sscanf(arg, "%d", &val); if (ret < 1) return "No value passed to avalon7-voltage"; if (val < AVA7_DEFAULT_VOLTAGE_MIN || val > AVA7_DEFAULT_VOLTAGE_MAX) return "Invalid value passed to avalon7-voltage"; opt_avalon7_voltage = val; return NULL; } char *set_avalon7_voltage_level(char *arg) { int val, ret; ret = sscanf(arg, "%d", &val); if (ret < 1) return "No value passed to avalon7-voltage-level"; if (val < AVA7_DEFAULT_VOLTAGE_LEVEL_MIN || val > AVA7_DEFAULT_VOLTAGE_LEVEL_MAX) return "Invalid value passed to avalon7-voltage-level"; opt_avalon7_voltage = convert_voltage_level(val); return NULL; } char *set_avalon7_voltage_offset(char *arg) { int val, ret; ret = sscanf(arg, "%d", &val); if (ret < 1) return "No value passed to avalon7-voltage-offset"; if (val < AVA7_DEFAULT_VOLTAGE_OFFSET_MIN || val > AVA7_DEFAULT_VOLTAGE_OFFSET_MAX) return "Invalid value passed to avalon7-voltage-offset"; opt_avalon7_voltage_offset = val; return NULL; } static int avalon7_init_pkg(struct avalon7_pkg *pkg, uint8_t type, uint8_t idx, uint8_t cnt) { unsigned short crc; pkg->head[0] = AVA7_H1; pkg->head[1] = AVA7_H2; pkg->type = type; pkg->opt = 0; pkg->idx = idx; pkg->cnt = cnt; crc = crc16(pkg->data, AVA7_P_DATA_LEN); pkg->crc[0] = (crc & 0xff00) >> 8; pkg->crc[1] = crc & 0xff; return 0; } static int job_idcmp(uint8_t *job_id, char *pool_job_id) { int job_id_len; unsigned short crc, crc_expect; if (!pool_job_id) return 1; job_id_len = strlen(pool_job_id); crc_expect = crc16((unsigned char *)pool_job_id, job_id_len); crc = job_id[0] << 8 | job_id[1]; if (crc_expect == crc) return 0; applog(LOG_DEBUG, "avalon7: job_id doesn't match! [%04x:%04x (%s)]", crc, crc_expect, pool_job_id); return 1; } static inline int get_temp_max(struct avalon7_info *info, int addr) { int i; int max = -273; for (i = 0; i < info->miner_count[addr]; i++) { if (info->temp[addr][i][3] > max) max = info->temp[addr][i][3]; } if (max < info->temp_mm[addr]) max = info->temp_mm[addr]; return max; } /* Use a PID-like feedback mechanism for optimal temperature and fan speed */ static inline uint32_t adjust_fan(struct avalon7_info *info, int id) { int t, tdiff, delta; uint32_t pwm; time_t now_t; now_t = time(NULL); t = get_temp_max(info, id); tdiff = t - info->temp_last_max[id]; if (!tdiff && now_t < info->last_temp_time[id] + AVA7_DEFAULT_FAN_INTERVAL) goto out; info->last_temp_time[id] = now_t; delta = t - info->temp_target[id]; /* Check for init value and ignore it */ if (unlikely(info->temp_last_max[id] == -273)) tdiff = 0; info->temp_last_max[id] = t; if (t >= info->temp_overheat[id]) { /* Hit the overheat temperature limit */ if (info->fan_pct[id] < opt_avalon7_fan_max) { applog(LOG_WARNING, "Overheat detected on AV7-%d, increasing fan to max", id); info->fan_pct[id] = opt_avalon7_fan_max; } } else if (delta > 0) { /* Over target temperature. */ /* Is the temp already coming down */ if (tdiff < 0) goto out; /* Adjust fanspeed by temperature over and any further rise */ info->fan_pct[id] += delta + tdiff; } else { /* Below target temperature */ int diff = tdiff; if (tdiff > 0) { int divisor = -delta / AVA7_DEFAULT_TEMP_HYSTERESIS + 1; /* Adjust fanspeed by temperature change proportional to * diff from optimal. */ diff /= divisor; } else { /* Is the temp below optimal and unchanging, gently lower speed */ if (t < info->temp_target[id] - AVA7_DEFAULT_TEMP_HYSTERESIS && !tdiff) diff -= 1; } info->fan_pct[id] += diff; } if (info->fan_pct[id] > opt_avalon7_fan_max) info->fan_pct[id] = opt_avalon7_fan_max; else if (info->fan_pct[id] < opt_avalon7_fan_min) info->fan_pct[id] = opt_avalon7_fan_min; out: pwm = get_fan_pwm(info->fan_pct[id]); if (info->cutoff[id]) pwm = get_fan_pwm(opt_avalon7_fan_max); applog(LOG_DEBUG, "[%d], Adjust_fan: %dC-%d%%(%03x)", id, t, info->fan_pct[id], pwm); return pwm; } static int decode_pkg(struct cgpu_info *avalon7, struct avalon7_ret *ar, int modular_id) { struct avalon7_info *info = avalon7->device_data; struct pool *pool, *real_pool; struct pool *pool_stratum0 = &info->pool0; struct pool *pool_stratum1 = &info->pool1; struct pool *pool_stratum2 = &info->pool2; struct thr_info *thr = NULL; unsigned short expected_crc; unsigned short actual_crc; uint32_t nonce, nonce2, ntime, miner, chip_id, tmp; uint8_t job_id[2]; int pool_no; uint32_t i; int64_t last_diff1; uint16_t vin; if (likely(avalon7->thr)) thr = avalon7->thr[0]; if (ar->head[0] != AVA7_H1 && ar->head[1] != AVA7_H2) { applog(LOG_DEBUG, "%s-%d-%d: H1 %02x, H2 %02x", avalon7->drv->name, avalon7->device_id, modular_id, ar->head[0], ar->head[1]); hexdump(ar->data, 32); return 1; } expected_crc = crc16(ar->data, AVA7_P_DATA_LEN); actual_crc = ((ar->crc[0] & 0xff) << 8) | (ar->crc[1] & 0xff); if (expected_crc != actual_crc) { applog(LOG_DEBUG, "%s-%d-%d: %02x: expected crc(%04x), actual_crc(%04x)", avalon7->drv->name, avalon7->device_id, modular_id, ar->type, expected_crc, actual_crc); return 1; } switch(ar->type) { case AVA7_P_NONCE: applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_NONCE", avalon7->drv->name, avalon7->device_id, modular_id); memcpy(&miner, ar->data + 0, 4); memcpy(&nonce2, ar->data + 4, 4); memcpy(&ntime, ar->data + 8, 4); memcpy(&nonce, ar->data + 12, 4); job_id[0] = ar->data[16]; job_id[1] = ar->data[17]; pool_no = (ar->data[18] | (ar->data[19] << 8)); miner = be32toh(miner); chip_id = (miner >> 16) & 0xffff; miner &= 0xffff; ntime = be32toh(ntime); if (miner >= info->miner_count[modular_id] || pool_no >= total_pools || pool_no < 0) { applog(LOG_DEBUG, "%s-%d-%d: Wrong miner/pool_no %d/%d", avalon7->drv->name, avalon7->device_id, modular_id, miner, pool_no); break; } nonce2 = be32toh(nonce2); nonce = be32toh(nonce); if (ntime > info->max_ntime) info->max_ntime = ntime; applog(LOG_DEBUG, "%s-%d-%d: Found! P:%d - N2:%08x N:%08x NR:%d/%d [M:%d - MW: (%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64")]", avalon7->drv->name, avalon7->device_id, modular_id, pool_no, nonce2, nonce, ntime, info->max_ntime, miner, info->chip_matching_work[modular_id][miner][0], info->chip_matching_work[modular_id][miner][1], info->chip_matching_work[modular_id][miner][2], info->chip_matching_work[modular_id][miner][3]); real_pool = pool = pools[pool_no]; if (job_idcmp(job_id, pool->swork.job_id)) { if (!job_idcmp(job_id, pool_stratum0->swork.job_id)) { applog(LOG_DEBUG, "%s-%d-%d: Match to previous stratum0! (%s)", avalon7->drv->name, avalon7->device_id, modular_id, pool_stratum0->swork.job_id); pool = pool_stratum0; } else if (!job_idcmp(job_id, pool_stratum1->swork.job_id)) { applog(LOG_DEBUG, "%s-%d-%d: Match to previous stratum1! (%s)", avalon7->drv->name, avalon7->device_id, modular_id, pool_stratum1->swork.job_id); pool = pool_stratum1; } else if (!job_idcmp(job_id, pool_stratum2->swork.job_id)) { applog(LOG_DEBUG, "%s-%d-%d: Match to previous stratum2! (%s)", avalon7->drv->name, avalon7->device_id, modular_id, pool_stratum2->swork.job_id); pool = pool_stratum2; } else { applog(LOG_ERR, "%s-%d-%d: Cannot match to any stratum! (%s)", avalon7->drv->name, avalon7->device_id, modular_id, pool->swork.job_id); if (likely(thr)) inc_hw_errors(thr); info->hw_works_i[modular_id][miner]++; break; } } /* Can happen during init sequence before add_cgpu */ if (unlikely(!thr)) break; last_diff1 = avalon7->diff1; if (!submit_nonce2_nonce(thr, pool, real_pool, nonce2, nonce, ntime)) info->hw_works_i[modular_id][miner]++; else { info->diff1[modular_id] += (avalon7->diff1 - last_diff1); info->chip_matching_work[modular_id][miner][chip_id]++; } break; case AVA7_P_STATUS: applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS", avalon7->drv->name, avalon7->device_id, modular_id); hexdump(ar->data, 32); memcpy(&tmp, ar->data, 4); tmp = be32toh(tmp); info->temp_mm[modular_id] = tmp; avalon7->temp = decode_auc_temp(info->auc_sensor); memcpy(&tmp, ar->data + 4, 4); tmp = be32toh(tmp); info->fan_cpm[modular_id] = tmp; memcpy(&tmp, ar->data + 8, 4); info->local_works_i[modular_id][ar->idx] += be32toh(tmp); memcpy(&tmp, ar->data + 12, 4); info->hw_works_i[modular_id][ar->idx] += be32toh(tmp); memcpy(&tmp, ar->data + 16, 4); info->error_code[modular_id][ar->idx] = be32toh(tmp); memcpy(&tmp, ar->data + 20, 4); info->error_code[modular_id][ar->cnt] = be32toh(tmp); memcpy(&tmp, ar->data + 24, 4); info->error_crc[modular_id][ar->idx] += be32toh(tmp); break; case AVA7_P_STATUS_PMU: /* TODO: decode ntc led from PMU */ applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS_PMU", avalon7->drv->name, avalon7->device_id, modular_id); info->power_good[modular_id] = ar->data[16]; for (i = 0; i < AVA7_DEFAULT_PMU_CNT; i++) { memcpy(&info->pmu_version[modular_id][i], ar->data + 24 + (i * 4), 4); info->pmu_version[modular_id][i][4] = '\0'; } for (i = 0; i < info->miner_count[modular_id]; i++) { memcpy(&vin, ar->data + 8 + i * 2, 2); info->get_vin[modular_id][i] = decode_vin(info, modular_id, be16toh(vin)); } break; case AVA7_P_STATUS_VOLT: applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS_VOLT", avalon7->drv->name, avalon7->device_id, modular_id); for (i = 0; i < info->miner_count[modular_id]; i++) { memcpy(&tmp, ar->data + i * 4, 4); info->get_voltage[modular_id][i] = decode_voltage(info, modular_id, be32toh(tmp)); } break; case AVA7_P_STATUS_PLL: applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS_PLL", avalon7->drv->name, avalon7->device_id, modular_id); for (i = 0; i < AVA7_DEFAULT_PLL_CNT; i++) { memcpy(&tmp, ar->data + i * 4, 4); info->get_pll[modular_id][ar->idx][i] = be32toh(tmp); } break; case AVA7_P_STATUS_PVT: applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS_PVT", avalon7->drv->name, avalon7->device_id, modular_id); for (i = 0; i < info->miner_count[modular_id]; i++) { memcpy(&tmp, ar->data + i * 8, 4); tmp = be32toh(tmp); info->temp[modular_id][i][0] = (tmp >> 24) & 0xff; info->temp[modular_id][i][1] = (tmp >> 16) & 0xff; info->temp[modular_id][i][2] = tmp & 0xffff; memcpy(&tmp, ar->data + (i + 1) * 8 - 4, 4); tmp = be32toh(tmp); info->temp[modular_id][i][3] = (tmp >> 16) & 0xffff; info->temp[modular_id][i][4] = tmp & 0xffff; /* Update the pvt code to real temperature */ info->temp[modular_id][i][2] = (int)decode_pvt_temp((uint16_t)info->temp[modular_id][i][2]); info->temp[modular_id][i][3] = (int)decode_pvt_temp((uint16_t)info->temp[modular_id][i][3]); info->temp[modular_id][i][4] = (int)decode_pvt_temp((uint16_t)info->temp[modular_id][i][4]); } break; case AVA7_P_STATUS_ASIC: { int x_miner_id; int x_asic_id; if (!info->asic_count[modular_id]) break; x_miner_id = ar->idx / info->asic_count[modular_id]; x_asic_id = ar->idx % info->asic_count[modular_id]; applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS_ASIC %d-%d", avalon7->drv->name, avalon7->device_id, modular_id, x_miner_id, x_asic_id); memcpy(&tmp, ar->data + 0, 4); if (tmp) { info->get_asic[modular_id][x_miner_id][x_asic_id][0] = be32toh(tmp); memcpy(&tmp, ar->data + 4, 4); info->get_asic[modular_id][x_miner_id][x_asic_id][1] = be32toh(tmp); memcpy(&tmp, ar->data + 8, 4); info->get_asic[modular_id][x_miner_id][x_asic_id][2] = be32toh(tmp); memcpy(&tmp, ar->data + 12, 4); info->get_asic[modular_id][x_miner_id][x_asic_id][3] = be32toh(tmp); memcpy(&tmp, ar->data + 16, 4); info->get_asic[modular_id][x_miner_id][x_asic_id][4] = be32toh(tmp); } tmp = *(ar->data + 20); info->get_asic[modular_id][x_miner_id][x_asic_id][5] = tmp; tmp = *(ar->data + 21); info->get_asic[modular_id][x_miner_id][x_asic_id][6] = tmp; tmp = *(ar->data + 22); info->get_asic[modular_id][x_miner_id][x_asic_id][7] = tmp; tmp = *(ar->data + 23); info->get_asic[modular_id][x_miner_id][x_asic_id][8] = tmp; tmp = *(ar->data + 24); info->get_asic[modular_id][x_miner_id][x_asic_id][9] = tmp; tmp = *(ar->data + 25); info->get_asic[modular_id][x_miner_id][x_asic_id][10] = tmp; } break; case AVA7_P_STATUS_FAC: applog(LOG_DEBUG, "%s-%d-%d: AVA7_P_STATUS_FAC", avalon7->drv->name, avalon7->device_id, modular_id); info->factory_info[0] = ar->data[0]; break; default: applog(LOG_DEBUG, "%s-%d-%d: Unknown response %x", avalon7->drv->name, avalon7->device_id, modular_id, ar->type); break; } return 0; } /* # IIC packet format: length[1]+transId[1]+sesId[1]+req[1]+data[60] # length: 4+len(data) # transId: 0 # sesId: 0 # req: checkout the header file # data: # INIT: clock_rate[4] + reserved[4] + payload[52] # XFER: txSz[1]+rxSz[1]+options[1]+slaveAddr[1] + payload[56] */ static int avalon7_auc_init_pkg(uint8_t *iic_pkg, struct avalon7_iic_info *iic_info, uint8_t *buf, int wlen, int rlen) { memset(iic_pkg, 0, AVA7_AUC_P_SIZE); switch (iic_info->iic_op) { case AVA7_IIC_INIT: iic_pkg[0] = 12; /* 4 bytes IIC header + 4 bytes speed + 4 bytes xfer delay */ iic_pkg[3] = AVA7_IIC_INIT; iic_pkg[4] = iic_info->iic_param.aucParam[0] & 0xff; iic_pkg[5] = (iic_info->iic_param.aucParam[0] >> 8) & 0xff; iic_pkg[6] = (iic_info->iic_param.aucParam[0] >> 16) & 0xff; iic_pkg[7] = iic_info->iic_param.aucParam[0] >> 24; iic_pkg[8] = iic_info->iic_param.aucParam[1] & 0xff; iic_pkg[9] = (iic_info->iic_param.aucParam[1] >> 8) & 0xff; iic_pkg[10] = (iic_info->iic_param.aucParam[1] >> 16) & 0xff; iic_pkg[11] = iic_info->iic_param.aucParam[1] >> 24; break; case AVA7_IIC_XFER: iic_pkg[0] = 8 + wlen; iic_pkg[3] = AVA7_IIC_XFER; iic_pkg[4] = wlen; iic_pkg[5] = rlen; iic_pkg[7] = iic_info->iic_param.slave_addr; if (buf && wlen) memcpy(iic_pkg + 8, buf, wlen); break; case AVA7_IIC_RESET: case AVA7_IIC_DEINIT: case AVA7_IIC_INFO: iic_pkg[0] = 4; iic_pkg[3] = iic_info->iic_op; break; default: break; } return 0; } static int avalon7_iic_xfer(struct cgpu_info *avalon7, uint8_t slave_addr, uint8_t *wbuf, int wlen, uint8_t *rbuf, int rlen) { struct avalon7_info *info = avalon7->device_data; struct i2c_ctx *pctx = NULL; int err = 1; bool ret = false; pctx = info->i2c_slaves[slave_addr]; if (!pctx) { applog(LOG_ERR, "%s-%d: IIC xfer i2c slaves null!", avalon7->drv->name, avalon7->device_id); goto out; } if (wbuf) { ret = pctx->write_raw(pctx, wbuf, wlen); if (!ret) { applog(LOG_DEBUG, "%s-%d: IIC xfer write raw failed!", avalon7->drv->name, avalon7->device_id); goto out; } } cgsleep_ms(5); if (rbuf) { ret = pctx->read_raw(pctx, rbuf, rlen); if (!ret) { applog(LOG_DEBUG, "%s-%d: IIC xfer read raw failed!", avalon7->drv->name, avalon7->device_id); hexdump(rbuf, rlen); goto out; } } return 0; out: return err; } static int avalon7_auc_xfer(struct cgpu_info *avalon7, uint8_t *wbuf, int wlen, int *write, uint8_t *rbuf, int rlen, int *read) { int err = -1; if (unlikely(avalon7->usbinfo.nodev)) goto out; usb_buffer_clear(avalon7); err = usb_write(avalon7, (char *)wbuf, wlen, write, C_AVA7_WRITE); if (err || *write != wlen) { applog(LOG_DEBUG, "%s-%d: AUC xfer %d, w(%d-%d)!", avalon7->drv->name, avalon7->device_id, err, wlen, *write); usb_nodev(avalon7); goto out; } cgsleep_ms(opt_avalon7_aucxdelay / 4800 + 1); rlen += 4; /* Add 4 bytes IIC header */ err = usb_read(avalon7, (char *)rbuf, rlen, read, C_AVA7_READ); if (err || *read != rlen || *read != rbuf[0]) { applog(LOG_DEBUG, "%s-%d: AUC xfer %d, r(%d-%d-%d)!", avalon7->drv->name, avalon7->device_id, err, rlen - 4, *read, rbuf[0]); hexdump(rbuf, rlen); return -1; } *read = rbuf[0] - 4; /* Remove 4 bytes IIC header */ out: return err; } static int avalon7_auc_init(struct cgpu_info *avalon7, char *ver) { struct avalon7_iic_info iic_info; int err, wlen, rlen; uint8_t wbuf[AVA7_AUC_P_SIZE]; uint8_t rbuf[AVA7_AUC_P_SIZE]; if (unlikely(avalon7->usbinfo.nodev)) return 1; /* Try to clean the AUC buffer */ usb_buffer_clear(avalon7); err = usb_read(avalon7, (char *)rbuf, AVA7_AUC_P_SIZE, &rlen, C_AVA7_READ); applog(LOG_DEBUG, "%s-%d: AUC usb_read %d, %d!", avalon7->drv->name, avalon7->device_id, err, rlen); hexdump(rbuf, AVA7_AUC_P_SIZE); /* Reset */ iic_info.iic_op = AVA7_IIC_RESET; rlen = 0; avalon7_auc_init_pkg(wbuf, &iic_info, NULL, 0, rlen); memset(rbuf, 0, AVA7_AUC_P_SIZE); err = avalon7_auc_xfer(avalon7, wbuf, AVA7_AUC_P_SIZE, &wlen, rbuf, rlen, &rlen); if (err) { applog(LOG_ERR, "%s-%d: Failed to reset Avalon USB2IIC Converter", avalon7->drv->name, avalon7->device_id); return 1; } /* Deinit */ iic_info.iic_op = AVA7_IIC_DEINIT; rlen = 0; avalon7_auc_init_pkg(wbuf, &iic_info, NULL, 0, rlen); memset(rbuf, 0, AVA7_AUC_P_SIZE); err = avalon7_auc_xfer(avalon7, wbuf, AVA7_AUC_P_SIZE, &wlen, rbuf, rlen, &rlen); if (err) { applog(LOG_ERR, "%s-%d: Failed to deinit Avalon USB2IIC Converter", avalon7->drv->name, avalon7->device_id); return 1; } /* Init */ iic_info.iic_op = AVA7_IIC_INIT; iic_info.iic_param.aucParam[0] = opt_avalon7_aucspeed; iic_info.iic_param.aucParam[1] = opt_avalon7_aucxdelay; rlen = AVA7_AUC_VER_LEN; avalon7_auc_init_pkg(wbuf, &iic_info, NULL, 0, rlen); memset(rbuf, 0, AVA7_AUC_P_SIZE); err = avalon7_auc_xfer(avalon7, wbuf, AVA7_AUC_P_SIZE, &wlen, rbuf, rlen, &rlen); if (err) { applog(LOG_ERR, "%s-%d: Failed to init Avalon USB2IIC Converter", avalon7->drv->name, avalon7->device_id); return 1; } hexdump(rbuf, AVA7_AUC_P_SIZE); memcpy(ver, rbuf + 4, AVA7_AUC_VER_LEN); ver[AVA7_AUC_VER_LEN] = '\0'; applog(LOG_DEBUG, "%s-%d: USB2IIC Converter version: %s!", avalon7->drv->name, avalon7->device_id, ver); return 0; } static int avalon7_auc_getinfo(struct cgpu_info *avalon7) { struct avalon7_iic_info iic_info; int err, wlen, rlen; uint8_t wbuf[AVA7_AUC_P_SIZE]; uint8_t rbuf[AVA7_AUC_P_SIZE]; uint8_t *pdata = rbuf + 4; uint16_t adc_val; struct avalon7_info *info = avalon7->device_data; iic_info.iic_op = AVA7_IIC_INFO; /* Device info: (9 bytes) * tempadc(2), reqRdIndex, reqWrIndex, * respRdIndex, respWrIndex, tx_flags, state * */ rlen = 7; avalon7_auc_init_pkg(wbuf, &iic_info, NULL, 0, rlen); memset(rbuf, 0, AVA7_AUC_P_SIZE); err = avalon7_auc_xfer(avalon7, wbuf, AVA7_AUC_P_SIZE, &wlen, rbuf, rlen, &rlen); if (err) { applog(LOG_ERR, "%s-%d: AUC Failed to get info ", avalon7->drv->name, avalon7->device_id); return 1; } applog(LOG_DEBUG, "%s-%d: AUC tempADC(%03d), reqcnt(%d), respcnt(%d), txflag(%d), state(%d)", avalon7->drv->name, avalon7->device_id, pdata[1] << 8 | pdata[0], pdata[2], pdata[3], pdata[5] << 8 | pdata[4], pdata[6]); adc_val = pdata[1] << 8 | pdata[0]; info->auc_sensor = 3.3 * adc_val * 10000 / 1023; return 0; } static int avalon7_iic_xfer_pkg(struct cgpu_info *avalon7, uint8_t slave_addr, const struct avalon7_pkg *pkg, struct avalon7_ret *ret) { struct avalon7_iic_info iic_info; int err, wcnt, rcnt, rlen = 0; uint8_t wbuf[AVA7_AUC_P_SIZE]; uint8_t rbuf[AVA7_AUC_P_SIZE]; struct avalon7_info *info = avalon7->device_data; if (ret) rlen = AVA7_READ_SIZE; if (info->connecter == AVA7_CONNECTER_AUC) { if (unlikely(avalon7->usbinfo.nodev)) return AVA7_SEND_ERROR; iic_info.iic_op = AVA7_IIC_XFER; iic_info.iic_param.slave_addr = slave_addr; avalon7_auc_init_pkg(wbuf, &iic_info, (uint8_t *)pkg, AVA7_WRITE_SIZE, rlen); err = avalon7_auc_xfer(avalon7, wbuf, wbuf[0], &wcnt, rbuf, rlen, &rcnt); if ((pkg->type != AVA7_P_DETECT) && err == -7 && !rcnt && rlen) { avalon7_auc_init_pkg(wbuf, &iic_info, NULL, 0, rlen); err = avalon7_auc_xfer(avalon7, wbuf, wbuf[0], &wcnt, rbuf, rlen, &rcnt); applog(LOG_DEBUG, "%s-%d-%d: AUC read again!(type:0x%x, err:%d)", avalon7->drv->name, avalon7->device_id, slave_addr, pkg->type, err); } if (err || rcnt != rlen) { if (info->xfer_err_cnt++ == 100) { applog(LOG_DEBUG, "%s-%d-%d: AUC xfer_err_cnt reach err = %d, rcnt = %d, rlen = %d", avalon7->drv->name, avalon7->device_id, slave_addr, err, rcnt, rlen); cgsleep_ms(5 * 1000); /* Wait MM reset */ if (avalon7_auc_init(avalon7, info->auc_version)) { applog(LOG_WARNING, "%s-%d: Failed to re-init auc, unplugging for new hotplug", avalon7->drv->name, avalon7->device_id); usb_nodev(avalon7); } } return AVA7_SEND_ERROR; } if (ret) memcpy((char *)ret, rbuf + 4, AVA7_READ_SIZE); info->xfer_err_cnt = 0; } if (info->connecter == AVA7_CONNECTER_IIC) { err = avalon7_iic_xfer(avalon7, slave_addr, (uint8_t *)pkg, AVA7_WRITE_SIZE, (uint8_t *)ret, AVA7_READ_SIZE); if ((pkg->type != AVA7_P_DETECT) && err) { err = avalon7_iic_xfer(avalon7, slave_addr, (uint8_t *)pkg, AVA7_WRITE_SIZE, (uint8_t *)ret, AVA7_READ_SIZE); applog(LOG_DEBUG, "%s-%d-%d: IIC read again!(type:0x%x, err:%d)", avalon7->drv->name, avalon7->device_id, slave_addr, pkg->type, err); } if (err) { /* FIXME: Don't care broadcast message with no reply, or it will block other thread when called by avalon7_send_bc_pkgs */ if ((pkg->type != AVA7_P_DETECT) && (slave_addr == AVA7_MODULE_BROADCAST)) return AVA7_SEND_OK; if (info->xfer_err_cnt++ == 100) { info->xfer_err_cnt = 0; applog(LOG_DEBUG, "%s-%d-%d: IIC xfer_err_cnt reach err = %d, rcnt = %d, rlen = %d", avalon7->drv->name, avalon7->device_id, slave_addr, err, rcnt, rlen); cgsleep_ms(5 * 1000); /* Wait MM reset */ } return AVA7_SEND_ERROR; } info->xfer_err_cnt = 0; } return AVA7_SEND_OK; } static int avalon7_send_bc_pkgs(struct cgpu_info *avalon7, const struct avalon7_pkg *pkg) { int ret; do { ret = avalon7_iic_xfer_pkg(avalon7, AVA7_MODULE_BROADCAST, pkg, NULL); } while (ret != AVA7_SEND_OK); return 0; } static void avalon7_stratum_pkgs(struct cgpu_info *avalon7, struct pool *pool) { struct avalon7_info *info = avalon7->device_data; const int merkle_offset = 36; struct avalon7_pkg pkg; int i, a, b; uint32_t tmp; unsigned char target[32]; int job_id_len, n2size; unsigned short crc; int coinbase_len_posthash, coinbase_len_prehash; uint8_t coinbase_prehash[32]; uint32_t range, start; /* Send out the first stratum message STATIC */ applog(LOG_DEBUG, "%s-%d: Pool stratum message STATIC: %d, %d, %d, %d, %d", avalon7->drv->name, avalon7->device_id, pool->coinbase_len, pool->nonce2_offset, pool->n2size, merkle_offset, pool->merkles); memset(pkg.data, 0, AVA7_P_DATA_LEN); tmp = be32toh(pool->coinbase_len); memcpy(pkg.data, &tmp, 4); tmp = be32toh(pool->nonce2_offset); memcpy(pkg.data + 4, &tmp, 4); n2size = pool->n2size >= 4 ? 4 : pool->n2size; tmp = be32toh(n2size); memcpy(pkg.data + 8, &tmp, 4); tmp = be32toh(merkle_offset); memcpy(pkg.data + 12, &tmp, 4); tmp = be32toh(pool->merkles); memcpy(pkg.data + 16, &tmp, 4); if (pool->n2size == 3) range = 0xffffff / (total_devices ? total_devices : 1); else range = 0xffffffff / (total_devices ? total_devices : 1); start = range * avalon7->device_id; tmp = be32toh(start); memcpy(pkg.data + 20, &tmp, 4); tmp = be32toh(range); memcpy(pkg.data + 24, &tmp, 4); if (info->work_restart) { info->work_restart = false; tmp = be32toh(0x1); memcpy(pkg.data + 28, &tmp, 4); } avalon7_init_pkg(&pkg, AVA7_P_STATIC, 1, 1); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; if (pool->sdiff <= AVA7_DRV_DIFFMAX) set_target(target, pool->sdiff); else set_target(target, AVA7_DRV_DIFFMAX); memcpy(pkg.data, target, 32); if (opt_debug) { char *target_str; target_str = bin2hex(target, 32); applog(LOG_DEBUG, "%s-%d: Pool stratum target: %s", avalon7->drv->name, avalon7->device_id, target_str); free(target_str); } avalon7_init_pkg(&pkg, AVA7_P_TARGET, 1, 1); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; memset(pkg.data, 0, AVA7_P_DATA_LEN); job_id_len = strlen(pool->swork.job_id); crc = crc16((unsigned char *)pool->swork.job_id, job_id_len); applog(LOG_DEBUG, "%s-%d: Pool stratum message JOBS_ID[%04x]: %s", avalon7->drv->name, avalon7->device_id, crc, pool->swork.job_id); tmp = ((crc << 16) | pool->pool_no); if (info->last_jobid != tmp) { info->last_jobid = tmp; pkg.data[0] = (crc & 0xff00) >> 8; pkg.data[1] = crc & 0xff; pkg.data[2] = pool->pool_no & 0xff; pkg.data[3] = (pool->pool_no & 0xff00) >> 8; avalon7_init_pkg(&pkg, AVA7_P_JOB_ID, 1, 1); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; } coinbase_len_prehash = pool->nonce2_offset - (pool->nonce2_offset % SHA256_BLOCK_SIZE); coinbase_len_posthash = pool->coinbase_len - coinbase_len_prehash; sha256_prehash(pool->coinbase, coinbase_len_prehash, coinbase_prehash); a = (coinbase_len_posthash / AVA7_P_DATA_LEN) + 1; b = coinbase_len_posthash % AVA7_P_DATA_LEN; memcpy(pkg.data, coinbase_prehash, 32); avalon7_init_pkg(&pkg, AVA7_P_COINBASE, 1, a + (b ? 1 : 0)); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; applog(LOG_DEBUG, "%s-%d: Pool stratum message modified COINBASE: %d %d", avalon7->drv->name, avalon7->device_id, a, b); for (i = 1; i < a; i++) { memcpy(pkg.data, pool->coinbase + coinbase_len_prehash + i * 32 - 32, 32); avalon7_init_pkg(&pkg, AVA7_P_COINBASE, i + 1, a + (b ? 1 : 0)); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; } if (b) { memset(pkg.data, 0, AVA7_P_DATA_LEN); memcpy(pkg.data, pool->coinbase + coinbase_len_prehash + i * 32 - 32, b); avalon7_init_pkg(&pkg, AVA7_P_COINBASE, i + 1, i + 1); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; } b = pool->merkles; applog(LOG_DEBUG, "%s-%d: Pool stratum message MERKLES: %d", avalon7->drv->name, avalon7->device_id, b); for (i = 0; i < b; i++) { memset(pkg.data, 0, AVA7_P_DATA_LEN); memcpy(pkg.data, pool->swork.merkle_bin[i], 32); avalon7_init_pkg(&pkg, AVA7_P_MERKLES, i + 1, b); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; } applog(LOG_DEBUG, "%s-%d: Pool stratum message HEADER: 4", avalon7->drv->name, avalon7->device_id); for (i = 0; i < 4; i++) { memset(pkg.data, 0, AVA7_P_DATA_LEN); memcpy(pkg.data, pool->header_bin + i * 32, 32); avalon7_init_pkg(&pkg, AVA7_P_HEADER, i + 1, 4); if (avalon7_send_bc_pkgs(avalon7, &pkg)) return; } if (info->connecter == AVA7_CONNECTER_AUC) avalon7_auc_getinfo(avalon7); } static struct cgpu_info *avalon7_iic_detect(void) { int i; struct avalon7_info *info; struct cgpu_info *avalon7 = NULL; struct i2c_ctx *i2c_slave = NULL; i2c_slave = i2c_slave_open(I2C_BUS, 0); if (!i2c_slave) { applog(LOG_ERR, "avalon7 init iic failed\n"); return NULL; } i2c_slave->exit(i2c_slave); i2c_slave = NULL; avalon7 = cgcalloc(1, sizeof(*avalon7)); avalon7->drv = &avalon7_drv; avalon7->deven = DEV_ENABLED; avalon7->threads = 1; add_cgpu(avalon7); applog(LOG_INFO, "%s-%d: Found at %s", avalon7->drv->name, avalon7->device_id, I2C_BUS); avalon7->device_data = cgcalloc(sizeof(struct avalon7_info), 1); memset(avalon7->device_data, 0, sizeof(struct avalon7_info)); info = avalon7->device_data; for (i = 0; i < AVA7_DEFAULT_MODULARS; i++) { info->enable[i] = false; info->reboot[i] = false; info->i2c_slaves[i] = i2c_slave_open(I2C_BUS, i); if (!info->i2c_slaves[i]) { applog(LOG_ERR, "avalon7 init i2c slaves failed\n"); free(avalon7->device_data); avalon7->device_data = NULL; free(avalon7); avalon7 = NULL; return NULL; } } info->connecter = AVA7_CONNECTER_IIC; return avalon7; } static void detect_modules(struct cgpu_info *avalon7); static struct cgpu_info *avalon7_auc_detect(struct libusb_device *dev, struct usb_find_devices *found) { int i, modules = 0; struct avalon7_info *info; struct cgpu_info *avalon7 = usb_alloc_cgpu(&avalon7_drv, 1); char auc_ver[AVA7_AUC_VER_LEN]; if (!usb_init(avalon7, dev, found)) { applog(LOG_ERR, "avalon7 failed usb_init"); avalon7 = usb_free_cgpu(avalon7); return NULL; } /* avalon7 prefers not to use zero length packets */ avalon7->nozlp = true; /* We try twice on AUC init */ if (avalon7_auc_init(avalon7, auc_ver) && avalon7_auc_init(avalon7, auc_ver)) return NULL; applog(LOG_INFO, "%s-%d: Found at %s", avalon7->drv->name, avalon7->device_id, avalon7->device_path); avalon7->device_data = cgcalloc(sizeof(struct avalon7_info), 1); memset(avalon7->device_data, 0, sizeof(struct avalon7_info)); info = avalon7->device_data; memcpy(info->auc_version, auc_ver, AVA7_AUC_VER_LEN); info->auc_version[AVA7_AUC_VER_LEN] = '\0'; info->auc_speed = opt_avalon7_aucspeed; info->auc_xdelay = opt_avalon7_aucxdelay; for (i = 0; i < AVA7_DEFAULT_MODULARS; i++) info->enable[i] = 0; info->connecter = AVA7_CONNECTER_AUC; detect_modules(avalon7); for (i = 0; i < AVA7_DEFAULT_MODULARS; i++) modules += info->enable[i]; if (!modules) { applog(LOG_INFO, "avalon7 found but no modules initialised"); free(info); avalon7 = usb_free_cgpu(avalon7); return NULL; } /* We have an avalon7 AUC connected */ avalon7->threads = 1; add_cgpu(avalon7); update_usb_stats(avalon7); return avalon7; } static inline void avalon7_detect(bool __maybe_unused hotplug) { usb_detect(&avalon7_drv, avalon7_auc_detect); if (!hotplug && opt_avalon7_iic_detect) avalon7_iic_detect(); } static bool avalon7_prepare(struct thr_info *thr) { struct cgpu_info *avalon7 = thr->cgpu; struct avalon7_info *info = avalon7->device_data; info->last_diff1 = 0; info->pending_diff1 = 0; info->last_rej = 0; info->mm_count = 0; info->xfer_err_cnt = 0; info->pool_no = 0; memset(&(info->firsthash), 0, sizeof(info->firsthash)); cgtime(&(info->last_fan_adj)); cgtime(&info->last_stratum); cgtime(&info->last_detect); cglock_init(&info->update_lock); cglock_init(&info->pool0.data_lock); cglock_init(&info->pool1.data_lock); cglock_init(&info->pool2.data_lock); return true; } static int check_module_exist(struct cgpu_info *avalon7, uint8_t mm_dna[AVA7_MM_DNA_LEN]) { struct avalon7_info *info = avalon7->device_data; int i; for (i = 0; i < AVA7_DEFAULT_MODULARS; i++) { /* last byte is \0 */ if (info->enable[i] && !memcmp(info->mm_dna[i], mm_dna, AVA7_MM_DNA_LEN)) return 1; } return 0; } static void detect_modules(struct cgpu_info *avalon7) { struct avalon7_info *info = avalon7->device_data; struct avalon7_pkg send_pkg; struct avalon7_ret ret_pkg; uint32_t tmp; int i, j, k, err, rlen; uint8_t dev_index; uint8_t rbuf[AVA7_AUC_P_SIZE]; /* Detect new modules here */ for (i = 1; i < AVA7_DEFAULT_MODULARS + 1; i++) { if (info->enable[i]) continue; /* Send out detect pkg */ applog(LOG_DEBUG, "%s-%d: AVA7_P_DETECT ID[%d]", avalon7->drv->name, avalon7->device_id, i); memset(send_pkg.data, 0, AVA7_P_DATA_LEN); tmp = be32toh(i); /* ID */ memcpy(send_pkg.data + 28, &tmp, 4); avalon7_init_pkg(&send_pkg, AVA7_P_DETECT, 1, 1); err = avalon7_iic_xfer_pkg(avalon7, AVA7_MODULE_BROADCAST, &send_pkg, &ret_pkg); if (err == AVA7_SEND_OK) { if (decode_pkg(avalon7, &ret_pkg, AVA7_MODULE_BROADCAST)) { applog(LOG_DEBUG, "%s-%d: Should be AVA7_P_ACKDETECT(%d), but %d", avalon7->drv->name, avalon7->device_id, AVA7_P_ACKDETECT, ret_pkg.type); continue; } } if (err != AVA7_SEND_OK) { applog(LOG_DEBUG, "%s-%d: AVA7_P_DETECT: Failed AUC xfer data with err %d", avalon7->drv->name, avalon7->device_id, err); break; } applog(LOG_DEBUG, "%s-%d: Module detect ID[%d]: %d", avalon7->drv->name, avalon7->device_id, i, ret_pkg.type); if (ret_pkg.type != AVA7_P_ACKDETECT) break; if (check_module_exist(avalon7, ret_pkg.data)) continue; /* Check count of modulars */ if (i == AVA7_DEFAULT_MODULARS) { applog(LOG_NOTICE, "You have connected more than %d machines. This is discouraged.", (AVA7_DEFAULT_MODULARS - 1)); info->conn_overloaded = true; break; } else info->conn_overloaded = false; memcpy(info->mm_version[i], ret_pkg.data + AVA7_MM_DNA_LEN, AVA7_MM_VER_LEN); info->mm_version[i][AVA7_MM_VER_LEN] = '\0'; for (dev_index = 0; dev_index < (sizeof(avalon7_dev_table) / sizeof(avalon7_dev_table[0])); dev_index++) { if (!strncmp((char *)&(info->mm_version[i]), (char *)(avalon7_dev_table[dev_index].dev_id_str), 3)) { info->mod_type[i] = avalon7_dev_table[dev_index].mod_type; info->miner_count[i] = avalon7_dev_table[dev_index].miner_count; info->asic_count[i] = avalon7_dev_table[dev_index].asic_count; info->vin_adc_ratio[i] = avalon7_dev_table[dev_index].vin_adc_ratio; info->vout_adc_ratio[i] = avalon7_dev_table[dev_index].vout_adc_ratio; break; } } if (dev_index == (sizeof(avalon7_dev_table) / sizeof(avalon7_dev_table[0]))) { applog(LOG_NOTICE, "%s-%d: The modular version %s cann't be support", avalon7->drv->name, avalon7->device_id, info->mm_version[i]); break; } info->enable[i] = 1; cgtime(&info->elapsed[i]); memcpy(info->mm_dna[i], ret_pkg.data, AVA7_MM_DNA_LEN); memcpy(&tmp, ret_pkg.data + AVA7_MM_DNA_LEN + AVA7_MM_VER_LEN, 4); tmp = be32toh(tmp); info->total_asics[i] = tmp; info->temp_overheat[i] = AVA7_DEFAULT_TEMP_OVERHEAT; info->temp_target[i] = opt_avalon7_temp_target; info->fan_pct[i] = opt_avalon7_fan_min; for (j = 0; j < info->miner_count[i]; j++) { if (opt_avalon7_voltage == AVA7_INVALID_VOLTAGE) info->set_voltage[i][j] = avalon7_dev_table[dev_index].set_voltage; else info->set_voltage[i][j] = opt_avalon7_voltage; info->get_voltage[i][j] = 0; info->get_vin[i][j] = 0; for (k = 0; k < 5; k++) info->temp[i][j][k] = -273; } info->freq_mode[i] = AVA7_FREQ_INIT_MODE; memset(info->set_frequency[i], 0, sizeof(unsigned int) * info->miner_count[i] * AVA7_DEFAULT_PLL_CNT); memset(info->get_pll[i], 0, sizeof(uint32_t) * info->miner_count[i] * AVA7_DEFAULT_PLL_CNT); memset(info->get_asic[i], 0, sizeof(uint32_t) * 11 * info->miner_count[i] * AVA7_DEFAULT_PLL_CNT); info->led_indicator[i] = 0; info->cutoff[i] = 0; info->fan_cpm[i] = 0; info->temp_mm[i] = -273; info->temp_last_max[i] = -273; info->local_works[i] = 0; info->hw_works[i] = 0; for (j = 0; j < info->miner_count[i]; j++) { memset(info->chip_matching_work[i][j], 0, sizeof(uint64_t) * info->asic_count[i]); info->local_works_i[i][j] = 0; info->hw_works_i[i][j] = 0; info->error_code[i][j] = 0; info->error_crc[i][j] = 0; } info->error_code[i][j] = 0; info->error_polling_cnt[i] = 0; info->power_good[i] = 0; memset(info->pmu_version[i], 0, sizeof(char) * 5 * AVA7_DEFAULT_PMU_CNT); info->diff1[i] = 0; applog(LOG_NOTICE, "%s-%d: New module detected! ID[%d-%x]", avalon7->drv->name, avalon7->device_id, i, info->mm_dna[i][AVA7_MM_DNA_LEN - 1]); /* Tell MM, it has been detected */ memset(send_pkg.data, 0, AVA7_P_DATA_LEN); memcpy(send_pkg.data, info->mm_dna[i], AVA7_MM_DNA_LEN); avalon7_init_pkg(&send_pkg, AVA7_P_SYNC, 1, 1); avalon7_iic_xfer_pkg(avalon7, i, &send_pkg, &ret_pkg); /* Keep the usb buffer is empty */ usb_buffer_clear(avalon7); usb_read(avalon7, (char *)rbuf, AVA7_AUC_P_SIZE, &rlen, C_AVA7_READ); } } static void detach_module(struct cgpu_info *avalon7, int addr) { struct avalon7_info *info = avalon7->device_data; info->enable[addr] = 0; applog(LOG_NOTICE, "%s-%d: Module detached! ID[%d]", avalon7->drv->name, avalon7->device_id, addr); } static int polling(struct cgpu_info *avalon7) { struct avalon7_info *info = avalon7->device_data; struct avalon7_pkg send_pkg; struct avalon7_ret ar; int i, tmp, ret, decode_err = 0; struct timeval current_fan; int do_adjust_fan = 0; uint32_t fan_pwm; double device_tdiff; cgtime(¤t_fan); device_tdiff = tdiff(¤t_fan, &(info->last_fan_adj)); if (device_tdiff > 2.0 || device_tdiff < 0) { cgtime(&info->last_fan_adj); do_adjust_fan = 1; } for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; cgsleep_ms(opt_avalon7_polling_delay); memset(send_pkg.data, 0, AVA7_P_DATA_LEN); /* Red LED */ tmp = be32toh(info->led_indicator[i]); memcpy(send_pkg.data, &tmp, 4); /* Adjust fan every 2 seconds*/ if (do_adjust_fan) { fan_pwm = adjust_fan(info, i); fan_pwm |= 0x80000000; tmp = be32toh(fan_pwm); memcpy(send_pkg.data + 4, &tmp, 4); } if (info->reboot[i]) { info->reboot[i] = false; send_pkg.data[8] = 0x1; } avalon7_init_pkg(&send_pkg, AVA7_P_POLLING, 1, 1); ret = avalon7_iic_xfer_pkg(avalon7, i, &send_pkg, &ar); if (ret == AVA7_SEND_OK) decode_err = decode_pkg(avalon7, &ar, i); if (ret != AVA7_SEND_OK || decode_err) { info->error_polling_cnt[i]++; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); avalon7_init_pkg(&send_pkg, AVA7_P_RSTMMTX, 1, 1); avalon7_iic_xfer_pkg(avalon7, i, &send_pkg, NULL); if (info->error_polling_cnt[i] >= 10) detach_module(avalon7, i); } if (ret == AVA7_SEND_OK && !decode_err) { info->error_polling_cnt[i] = 0; if ((ar.opt == AVA7_P_STATUS) && (info->mm_dna[i][AVA7_MM_DNA_LEN - 1] != ar.opt)) { applog(LOG_ERR, "%s-%d-%d: Dup address found %d-%d", avalon7->drv->name, avalon7->device_id, i, info->mm_dna[i][AVA7_MM_DNA_LEN - 1], ar.opt); hexdump((uint8_t *)&ar, sizeof(ar)); detach_module(avalon7, i); } } } return 0; } static void copy_pool_stratum(struct pool *pool_stratum, struct pool *pool) { int i; int merkles = pool->merkles, job_id_len; size_t coinbase_len = pool->coinbase_len; unsigned short crc; if (!pool->swork.job_id) return; if (pool_stratum->swork.job_id) { job_id_len = strlen(pool->swork.job_id); crc = crc16((unsigned char *)pool->swork.job_id, job_id_len); job_id_len = strlen(pool_stratum->swork.job_id); if (crc16((unsigned char *)pool_stratum->swork.job_id, job_id_len) == crc) 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 void avalon7_init_setting(struct cgpu_info *avalon7, int addr) { struct avalon7_pkg send_pkg; uint32_t tmp; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); /* TODO:ss/ssp mode */ tmp = be32toh(opt_avalon7_freq_sel); memcpy(send_pkg.data + 4, &tmp, 4); /* adjust flag [0-5]: reserved, 6: nonce check, 7: autof*/ tmp = 1; if (!opt_avalon7_smart_speed) tmp = 0; tmp |= (1 << 1); /* Enable nonce check */ tmp |= (opt_avalon7_asic_debug << 2); send_pkg.data[8] = tmp & 0xff; send_pkg.data[9] = opt_avalon7_nonce_mask & 0xff; /* Package the data */ avalon7_init_pkg(&send_pkg, AVA7_P_SET, 1, 1); if (addr == AVA7_MODULE_BROADCAST) avalon7_send_bc_pkgs(avalon7, &send_pkg); else avalon7_iic_xfer_pkg(avalon7, addr, &send_pkg, NULL); } static void avalon7_set_voltage(struct cgpu_info *avalon7, int addr, unsigned int voltage[]) { struct avalon7_info *info = avalon7->device_data; struct avalon7_pkg send_pkg; uint32_t tmp; uint8_t i; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); /* FIXME: miner_count should <= 8 */ for (i = 0; i < info->miner_count[addr]; i++) { tmp = be32toh(encode_voltage(voltage[i] + opt_avalon7_voltage_offset * AVA7_DEFAULT_VOLTAGE_STEP)); memcpy(send_pkg.data + i * 4, &tmp, 4); } applog(LOG_DEBUG, "%s-%d-%d: avalon7 set voltage miner %d, (%d-%d)", avalon7->drv->name, avalon7->device_id, addr, i, voltage[0], voltage[info->miner_count[addr] - 1]); /* Package the data */ avalon7_init_pkg(&send_pkg, AVA7_P_SET_VOLT, 1, 1); if (addr == AVA7_MODULE_BROADCAST) avalon7_send_bc_pkgs(avalon7, &send_pkg); else avalon7_iic_xfer_pkg(avalon7, addr, &send_pkg, NULL); } static void avalon7_set_freq(struct cgpu_info *avalon7, int addr, int miner_id, unsigned int freq[]) { struct avalon7_info *info = avalon7->device_data; struct avalon7_pkg send_pkg; uint32_t tmp, f; uint8_t i; send_pkg.idx = 0; /* TODO: This is only for broadcast to all miners * This should be support 4 miners */ send_pkg.cnt = info->miner_count[addr]; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); for (i = 0; i < AVA7_DEFAULT_PLL_CNT; i++) { tmp = be32toh(api_get_cpm(freq[i])); memcpy(send_pkg.data + i * 4, &tmp, 4); } f = freq[0]; for (i = 1; i < AVA7_DEFAULT_PLL_CNT; i++) f = f > freq[i] ? f : freq[i]; tmp = ((AVA7_ASIC_TIMEOUT_CONST / f) * 40 / 4); tmp = be32toh(tmp); memcpy(send_pkg.data + AVA7_DEFAULT_PLL_CNT * 4, &tmp, 4); tmp = AVA7_ASIC_TIMEOUT_CONST / f * 98 / 100; tmp = be32toh(tmp); memcpy(send_pkg.data + AVA7_DEFAULT_PLL_CNT * 4 + 4, &tmp, 4); applog(LOG_DEBUG, "%s-%d-%d: avalon7 set freq miner %x-%x", avalon7->drv->name, avalon7->device_id, addr, miner_id, be32toh(tmp)); /* Package the data */ avalon7_init_pkg(&send_pkg, AVA7_P_SET_PLL, miner_id + 1, info->miner_count[addr]); if (addr == AVA7_MODULE_BROADCAST) avalon7_send_bc_pkgs(avalon7, &send_pkg); else avalon7_iic_xfer_pkg(avalon7, addr, &send_pkg, NULL); } static void avalon7_set_factory_info(struct cgpu_info *avalon7, int addr, uint8_t value[]) { struct avalon7_pkg send_pkg; uint8_t i; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); for (i = 0; i < AVA7_DEFAULT_FACTORY_INFO_CNT; i++) send_pkg.data[i] = value[i]; /* Package the data */ avalon7_init_pkg(&send_pkg, AVA7_P_SET_FAC, 1, 1); if (addr == AVA7_MODULE_BROADCAST) avalon7_send_bc_pkgs(avalon7, &send_pkg); else avalon7_iic_xfer_pkg(avalon7, addr, &send_pkg, NULL); } static void avalon7_set_ss_param(struct cgpu_info *avalon7, int addr) { struct avalon7_pkg send_pkg; uint32_t tmp; if (!opt_avalon7_smart_speed) return; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); tmp = be32toh(opt_avalon7_th_pass); memcpy(send_pkg.data, &tmp, 4); applog(LOG_DEBUG, "%s-%d-%d: avalon7 set th pass %u", avalon7->drv->name, avalon7->device_id, addr, opt_avalon7_th_pass); tmp = be32toh(opt_avalon7_th_fail); memcpy(send_pkg.data + 4, &tmp, 4); applog(LOG_DEBUG, "%s-%d-%d: avalon7 set th fail %u", avalon7->drv->name, avalon7->device_id, addr, opt_avalon7_th_fail); tmp = be32toh(opt_avalon7_th_init); memcpy(send_pkg.data + 8, &tmp, 4); applog(LOG_DEBUG, "%s-%d-%d: avalon7 set th init %u", avalon7->drv->name, avalon7->device_id, addr, opt_avalon7_th_init); tmp = be32toh(opt_avalon7_th_ms); memcpy(send_pkg.data + 12, &tmp, 4); applog(LOG_DEBUG, "%s-%d-%d: avalon7 set th ms %u", avalon7->drv->name, avalon7->device_id, addr, opt_avalon7_th_ms); tmp = be32toh(opt_avalon7_th_timeout); memcpy(send_pkg.data + 16, &tmp, 4); applog(LOG_DEBUG, "%s-%d-%d: avalon7 set th timeout %u", avalon7->drv->name, avalon7->device_id, addr, opt_avalon7_th_timeout); /* Package the data */ avalon7_init_pkg(&send_pkg, AVA7_P_SET_SS, 1, 1); if (addr == AVA7_MODULE_BROADCAST) avalon7_send_bc_pkgs(avalon7, &send_pkg); else avalon7_iic_xfer_pkg(avalon7, addr, &send_pkg, NULL); } static void avalon7_stratum_finish(struct cgpu_info *avalon7) { struct avalon7_pkg send_pkg; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); avalon7_init_pkg(&send_pkg, AVA7_P_JOB_FIN, 1, 1); avalon7_send_bc_pkgs(avalon7, &send_pkg); } static void avalon7_set_finish(struct cgpu_info *avalon7, int addr) { struct avalon7_pkg send_pkg; memset(send_pkg.data, 0, AVA7_P_DATA_LEN); avalon7_init_pkg(&send_pkg, AVA7_P_SET_FIN, 1, 1); avalon7_iic_xfer_pkg(avalon7, addr, &send_pkg, NULL); } static void avalon7_sswork_update(struct cgpu_info *avalon7) { struct avalon7_info *info = avalon7->device_data; struct thr_info *thr = avalon7->thr[0]; struct pool *pool; int coinbase_len_posthash, coinbase_len_prehash; /* * NOTE: We need mark work_restart to private information, * So that it cann't reset by hash_driver_work */ if (thr->work_restart) info->work_restart = thr->work_restart; applog(LOG_DEBUG, "%s-%d: New stratum: restart: %d, update: %d", avalon7->drv->name, avalon7->device_id, thr->work_restart, thr->work_update); /* Step 1: MM protocol check */ pool = current_pool(); if (!pool->has_stratum) quit(1, "%s-%d: MM has to use stratum pools", avalon7->drv->name, avalon7->device_id); coinbase_len_prehash = pool->nonce2_offset - (pool->nonce2_offset % SHA256_BLOCK_SIZE); coinbase_len_posthash = pool->coinbase_len - coinbase_len_prehash; if (coinbase_len_posthash + SHA256_BLOCK_SIZE > AVA7_P_COINBASE_SIZE) { applog(LOG_ERR, "%s-%d: MM pool modified coinbase length(%d) is more than %d", avalon7->drv->name, avalon7->device_id, coinbase_len_posthash + SHA256_BLOCK_SIZE, AVA7_P_COINBASE_SIZE); return; } if (pool->merkles > AVA7_P_MERKLES_COUNT) { applog(LOG_ERR, "%s-%d: MM merkles has to be less then %d", avalon7->drv->name, avalon7->device_id, AVA7_P_MERKLES_COUNT); return; } if (pool->n2size < 3) { applog(LOG_ERR, "%s-%d: MM nonce2 size has to be >= 3 (%d)", avalon7->drv->name, avalon7->device_id, pool->n2size); return; } cg_wlock(&info->update_lock); /* Step 2: Send out stratum pkgs */ cg_rlock(&pool->data_lock); cgtime(&info->last_stratum); info->pool_no = pool->pool_no; copy_pool_stratum(&info->pool2, &info->pool1); copy_pool_stratum(&info->pool1, &info->pool0); copy_pool_stratum(&info->pool0, pool); avalon7_stratum_pkgs(avalon7, pool); cg_runlock(&pool->data_lock); /* Step 3: Send out finish pkg */ avalon7_stratum_finish(avalon7); cg_wunlock(&info->update_lock); } static int64_t avalon7_scanhash(struct thr_info *thr) { struct cgpu_info *avalon7 = thr->cgpu; struct avalon7_info *info = avalon7->device_data; struct timeval current; int i, j, k, count = 0; int temp_max; int64_t ret; bool update_settings = false; if ((info->connecter == AVA7_CONNECTER_AUC) && (unlikely(avalon7->usbinfo.nodev))) { applog(LOG_ERR, "%s-%d: Device disappeared, shutting down thread", avalon7->drv->name, avalon7->device_id); return -1; } /* Step 1: Stop polling and detach the device if there is no stratum in 3 minutes, network is down */ cgtime(¤t); if (tdiff(¤t, &(info->last_stratum)) > 180.0) { for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; detach_module(avalon7, i); } info->mm_count = 0; return 0; } /* Step 2: Try to detect new modules */ if ((tdiff(¤t, &(info->last_detect)) > AVA7_MODULE_DETECT_INTERVAL) || !info->mm_count) { cgtime(&info->last_detect); detect_modules(avalon7); } /* Step 3: ASIC configrations (voltage and frequency) */ for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; update_settings = false; /* Check temperautre */ temp_max = get_temp_max(info, i); /* Enter too hot */ if (temp_max >= info->temp_overheat[i]) info->cutoff[i] = 1; /* Exit too hot */ if (info->cutoff[i] && (temp_max <= (info->temp_overheat[i] - 10))) info->cutoff[i] = 0; switch (info->freq_mode[i]) { case AVA7_FREQ_INIT_MODE: update_settings = true; /* Make sure to send configuration first */ thr->work_update = false; for (j = 0; j < info->miner_count[i]; j++) { for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) info->set_frequency[i][j][k] = opt_avalon7_freq[k]; } avalon7_init_setting(avalon7, i); info->freq_mode[i] = AVA7_FREQ_PLLADJ_MODE; break; case AVA7_FREQ_PLLADJ_MODE: if (opt_avalon7_smart_speed == AVA7_DEFAULT_SMARTSPEED_OFF) break; /* AVA7_DEFAULT_SMARTSPEED_MODE1: auto speed by A3212 chips */ break; default: applog(LOG_ERR, "%s-%d-%d: Invalid frequency mode %d", avalon7->drv->name, avalon7->device_id, i, info->freq_mode[i]); break; } if (update_settings) { cg_wlock(&info->update_lock); avalon7_set_voltage(avalon7, i, info->set_voltage[i]); for (j = 0; j < info->miner_count[i]; j++) avalon7_set_freq(avalon7, i, j, info->set_frequency[i][j]); if (opt_avalon7_smart_speed) avalon7_set_ss_param(avalon7, i); avalon7_set_finish(avalon7, i); cg_wunlock(&info->update_lock); } } /* Step 4: Polling */ cg_rlock(&info->update_lock); polling(avalon7); cg_runlock(&info->update_lock); /* Step 5: Calculate mm count */ for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (info->enable[i]) count++; } info->mm_count = count; /* Step 6: Calculate hashes. Use the diff1 value which is scaled by * device diff and is usually lower than pool diff which will give a * more stable result, but remove diff rejected shares to more closely * approximate diff accepted values. */ info->pending_diff1 += avalon7->diff1 - info->last_diff1; info->last_diff1 = avalon7->diff1; info->pending_diff1 -= avalon7->diff_rejected - info->last_rej; info->last_rej = avalon7->diff_rejected; if (info->pending_diff1 && !info->firsthash.tv_sec) { cgtime(&info->firsthash); copy_time(&(avalon7->dev_start_tv), &(info->firsthash)); } if (info->pending_diff1 <= 0) ret = 0; else { ret = info->pending_diff1; info->pending_diff1 = 0; } return ret * 0xffffffffull; } static float avalon7_hash_cal(struct cgpu_info *avalon7, int modular_id) { struct avalon7_info *info = avalon7->device_data; uint32_t tmp_freq[AVA7_DEFAULT_PLL_CNT]; unsigned int i, j; float mhsmm; mhsmm = 0; for (i = 0; i < info->miner_count[modular_id]; i++) { for (j = 0; j < AVA7_DEFAULT_PLL_CNT; j++) tmp_freq[j] = info->set_frequency[modular_id][i][j]; for (j = 0; j < AVA7_DEFAULT_PLL_CNT; j++) mhsmm += (info->get_pll[modular_id][i][j] * tmp_freq[j]); } return mhsmm; } #define STATBUFLEN_WITHOUT_DBG (6 * 1024) #define STATBUFLEN_WITH_DBG (6 * 7 * 1024) static struct api_data *avalon7_api_stats(struct cgpu_info *avalon7) { struct api_data *root = NULL; struct avalon7_info *info = avalon7->device_data; int i, j, k; double a, b, dh; char buf[256]; char *statbuf = NULL; struct timeval current; float mhsmm, auc_temp = 0.0; cgtime(¤t); if (opt_debug) statbuf = cgcalloc(STATBUFLEN_WITH_DBG, 1); else statbuf = cgcalloc(STATBUFLEN_WITHOUT_DBG, 1); for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; sprintf(buf, "Ver[%s]", info->mm_version[i]); strcpy(statbuf, buf); sprintf(buf, " DNA[%02x%02x%02x%02x%02x%02x%02x%02x]", info->mm_dna[i][0], info->mm_dna[i][1], info->mm_dna[i][2], info->mm_dna[i][3], info->mm_dna[i][4], info->mm_dna[i][5], info->mm_dna[i][6], info->mm_dna[i][7]); strcat(statbuf, buf); sprintf(buf, " Elapsed[%.0f]", tdiff(¤t, &(info->elapsed[i]))); strcat(statbuf, buf); strcat(statbuf, " MW["); info->local_works[i] = 0; for (j = 0; j < info->miner_count[i]; j++) { info->local_works[i] += info->local_works_i[i][j]; sprintf(buf, "%"PRIu64" ", info->local_works_i[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; sprintf(buf, " LW[%"PRIu64"]", info->local_works[i]); strcat(statbuf, buf); strcat(statbuf, " MH["); info->hw_works[i] = 0; for (j = 0; j < info->miner_count[i]; j++) { info->hw_works[i] += info->hw_works_i[i][j]; sprintf(buf, "%"PRIu64" ", info->hw_works_i[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; sprintf(buf, " HW[%"PRIu64"]", info->hw_works[i]); strcat(statbuf, buf); a = 0; b = 0; for (j = 0; j < info->miner_count[i]; j++) { for (k = 0; k < info->asic_count[i]; k++) { a += info->get_asic[i][j][k][0]; b += info->get_asic[i][j][k][1]; } } dh = b ? (b / (a + b)) * 100: 0; sprintf(buf, " DH[%.3f%%]", dh); strcat(statbuf, buf); sprintf(buf, " Temp[%d]", info->temp_mm[i]); strcat(statbuf, buf); sprintf(buf, " TMax[%d]", get_temp_max(info, i)); strcat(statbuf, buf); sprintf(buf, " Fan[%d]", info->fan_cpm[i]); strcat(statbuf, buf); sprintf(buf, " FanR[%d%%]", info->fan_pct[i]); strcat(statbuf, buf); sprintf(buf, " Vi["); strcat(statbuf, buf); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, "%d ", info->get_vin[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; sprintf(buf, " Vo["); strcat(statbuf, buf); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, "%d ", info->get_voltage[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; if (opt_debug) { for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, " PLL%d[", j); strcat(statbuf, buf); for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) { sprintf(buf, "%d ", info->get_pll[i][j][k]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; } } mhsmm = avalon7_hash_cal(avalon7, i); sprintf(buf, " GHSmm[%.2f] WU[%.2f] Freq[%.2f]", (float)mhsmm / 1000, info->diff1[i] / tdiff(¤t, &(info->elapsed[i])) * 60.0, (float)mhsmm / (info->asic_count[i] * info->miner_count[i] * 128)); strcat(statbuf, buf); sprintf(buf, " PG[%d]", info->power_good[i]); strcat(statbuf, buf); sprintf(buf, " Led[%d]", info->led_indicator[i]); strcat(statbuf, buf); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, " MW%d[", j); strcat(statbuf, buf); for (k = 0; k < info->asic_count[i]; k++) { sprintf(buf, "%"PRIu64" ", info->chip_matching_work[i][j][k]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; } sprintf(buf, " TA[%d]", info->total_asics[i]); strcat(statbuf, buf); strcat(statbuf, " ECHU["); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, "%d ", info->error_code[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; sprintf(buf, " ECMM[%d]", info->error_code[i][j]); strcat(statbuf, buf); if (opt_debug) { sprintf(buf, " FAC0[%d]", info->factory_info[0]); strcat(statbuf, buf); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, " SF%d[", j); strcat(statbuf, buf); for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) { sprintf(buf, "%d ", info->set_frequency[i][j][k]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; } strcat(statbuf, " PMUV["); for (j = 0; j < AVA7_DEFAULT_PMU_CNT; j++) { sprintf(buf, "%s ", info->pmu_version[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, " ERATIO%d[", j); strcat(statbuf, buf); for (k = 0; k < info->asic_count[i]; k++) { if (info->get_asic[i][j][k][0]) sprintf(buf, "%.2f%% ", (double)(info->get_asic[i][j][k][1] * 100.0 / (info->get_asic[i][j][k][0] + info->get_asic[i][j][k][1]))); else sprintf(buf, "%.2f%% ", 0.0); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; } int l; /* i: modular, j: miner, k:asic, l:value */ for (l = 0; l < 5; l++) { for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, " C_%d_%02d[", j, l); strcat(statbuf, buf); for (k = 0; k < info->asic_count[i]; k++) { sprintf(buf, "%5d ", info->get_asic[i][j][k][l]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; } } for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, " GHSmm%02d[", j); strcat(statbuf, buf); for (k = 0; k < info->asic_count[i]; k++) { mhsmm = 0; for (l = 5; l < 11; l++) mhsmm += (info->get_asic[i][j][k][l] * info->set_frequency[i][j][l - 5]); sprintf(buf, "%.2f ", mhsmm / 1000); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; } } sprintf(buf, " FM[%d]", info->freq_mode[i]); strcat(statbuf, buf); strcat(statbuf, " CRC["); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, "%d ", info->error_crc[i][j]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; strcat(statbuf, " PVT_T["); for (j = 0; j < info->miner_count[i]; j++) { sprintf(buf, "%d-%d/%d-%d/%d ", info->temp[i][j][0], info->temp[i][j][2], info->temp[i][j][1], info->temp[i][j][3], info->temp[i][j][4]); strcat(statbuf, buf); } statbuf[strlen(statbuf) - 1] = ']'; statbuf[strlen(statbuf)] = '\0'; sprintf(buf, "MM ID%d", i); root = api_add_string(root, buf, statbuf, true); } free(statbuf); root = api_add_int(root, "MM Count", &(info->mm_count), true); root = api_add_int(root, "Smart Speed", &opt_avalon7_smart_speed, true); if (info->connecter == AVA7_CONNECTER_IIC) root = api_add_string(root, "Connecter", "IIC", true); if (info->connecter == AVA7_CONNECTER_AUC) { root = api_add_string(root, "Connecter", "AUC", true); root = api_add_string(root, "AUC VER", info->auc_version, false); root = api_add_int(root, "AUC I2C Speed", &(info->auc_speed), true); root = api_add_int(root, "AUC I2C XDelay", &(info->auc_xdelay), true); root = api_add_int(root, "AUC Sensor", &(info->auc_sensor), true); auc_temp = decode_auc_temp(info->auc_sensor); root = api_add_temp(root, "AUC Temperature", &auc_temp, true); } root = api_add_bool(root, "Connection Overloaded", &info->conn_overloaded, true); root = api_add_int(root, "Voltage Offset", &opt_avalon7_voltage_offset, true); root = api_add_uint32(root, "Nonce Mask", &opt_avalon7_nonce_mask, true); return root; } /* format: voltage[-addr[-miner]] * add4[0, AVA7_DEFAULT_MODULARS - 1], 0 means all modulars * miner[0, miner_count], 0 means all miners */ char *set_avalon7_device_voltage(struct cgpu_info *avalon7, char *arg) { struct avalon7_info *info = avalon7->device_data; unsigned int val, addr = 0, i, j; uint32_t miner_id = 0; if (!(*arg)) return NULL; sscanf(arg, "%d-%d-%d", &val, &addr, &miner_id); if (!val) val = AVA7_DEFAULT_VOLTAGE_MIN; if (val < AVA7_DEFAULT_VOLTAGE_MIN || val > AVA7_DEFAULT_VOLTAGE_MAX) return "Invalid value passed to set_avalon7_device_voltage"; if (addr >= AVA7_DEFAULT_MODULARS) { applog(LOG_ERR, "invalid modular index: %d, valid range 0-%d", addr, (AVA7_DEFAULT_MODULARS - 1)); return "Invalid modular index to set_avalon7_device_voltage"; } if (!info->enable[addr]) { applog(LOG_ERR, "Disabled modular:%d", addr); return "Disabled modular to set_avalon7_device_voltage"; } if (miner_id > info->miner_count[addr]) { applog(LOG_ERR, "invalid miner index: %d, valid range 0-%d", miner_id, info->miner_count[addr]); return "Invalid miner index to set_avalon7_device_voltage"; } if (!addr) { for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; if (miner_id) info->set_voltage[i][miner_id - 1] = val; else { for (j = 0; j < info->miner_count[i]; j++) info->set_voltage[i][j] = val; } avalon7_set_voltage(avalon7, i, info->set_voltage[i]); } } else { if (miner_id) info->set_voltage[addr][miner_id - 1] = val; else { for (j = 0; j < info->miner_count[addr]; j++) info->set_voltage[addr][j] = val; } avalon7_set_voltage(avalon7, addr, info->set_voltage[addr]); } applog(LOG_NOTICE, "%s-%d: Update voltage to %d", avalon7->drv->name, avalon7->device_id, val); return NULL; } /* format: freq[-addr[-miner]] * add4[0, AVA7_DEFAULT_MODULARS - 1], 0 means all modulars * miner[0, miner_count], 0 means all miners */ char *set_avalon7_device_freq(struct cgpu_info *avalon7, char *arg) { struct avalon7_info *info = avalon7->device_data; unsigned int val, addr = 0, i, j, k; uint32_t miner_id = 0; if (!(*arg)) return NULL; sscanf(arg, "%d-%d-%d", &val, &addr, &miner_id); if (!val) val = AVA7_DEFAULT_FREQUENCY_MIN; if (val < AVA7_DEFAULT_FREQUENCY_MIN || val > AVA7_DEFAULT_FREQUENCY_MAX) return "Invalid value passed to set_avalon7_device_freq"; if (addr >= AVA7_DEFAULT_MODULARS) { applog(LOG_ERR, "invalid modular index: %d, valid range 0-%d", addr, (AVA7_DEFAULT_MODULARS - 1)); return "Invalid modular index to set_avalon7_device_freq"; } if (!info->enable[addr]) { applog(LOG_ERR, "Disabled modular:%d", addr); return "Disabled modular to set_avalon7_device_freq"; } if (miner_id > info->miner_count[addr]) { applog(LOG_ERR, "invalid miner index: %d, valid range 0-%d", miner_id, info->miner_count[addr]); return "Invalid miner index to set_avalon7_device_freq"; } if (!addr) { for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; if (miner_id) { for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) info->set_frequency[i][miner_id - 1][k] = val; avalon7_set_freq(avalon7, i, miner_id, info->set_frequency[i][miner_id]); } else { for (j = 0; j < info->miner_count[i]; j++) { for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) info->set_frequency[i][j][k] = val; avalon7_set_freq(avalon7, i, j, info->set_frequency[i][j]); } } } } else { if (miner_id) { for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) info->set_frequency[addr][miner_id - 1][k] = val; avalon7_set_freq(avalon7, addr, miner_id, info->set_frequency[addr][miner_id]); } else { for (j = 0; j < info->miner_count[addr]; j++) { for (k = 0; k < AVA7_DEFAULT_PLL_CNT; k++) info->set_frequency[addr][j][k] = val; avalon7_set_freq(avalon7, addr, j, info->set_frequency[addr][j]); } } } applog(LOG_NOTICE, "%s-%d: Update frequency to %d", avalon7->drv->name, avalon7->device_id, val); return NULL; } char *set_avalon7_factory_info(struct cgpu_info *avalon7, char *arg) { struct avalon7_info *info = avalon7->device_data; int val; if (!(*arg)) return NULL; sscanf(arg, "%d", &val); if (!val) val = AVA7_DEFAULT_FACTORY_INFO_0; if (val < AVA7_DEFAULT_FACTORY_INFO_0_MIN || val > AVA7_DEFAULT_FACTORY_INFO_0_MAX) return "Invalid value passed to set_avalon7_factory_info"; info->factory_info[0] = val; avalon7_set_factory_info(avalon7, 0, (uint8_t *)info->factory_info); applog(LOG_NOTICE, "%s-%d: Update factory info %d", avalon7->drv->name, avalon7->device_id, val); return NULL; } static char *avalon7_set_device(struct cgpu_info *avalon7, char *option, char *setting, char *replybuf) { unsigned int val; struct avalon7_info *info = avalon7->device_data; if (strcasecmp(option, "help") == 0) { sprintf(replybuf, "pdelay|fan|frequency|led|voltage"); return replybuf; } if (strcasecmp(option, "pdelay") == 0) { if (!setting || !*setting) { sprintf(replybuf, "missing polling delay setting"); return replybuf; } val = (unsigned int)atoi(setting); if (val < 1 || val > 65535) { sprintf(replybuf, "invalid polling delay: %d, valid range 1-65535", val); return replybuf; } opt_avalon7_polling_delay = val; applog(LOG_NOTICE, "%s-%d: Update polling delay to: %d", avalon7->drv->name, avalon7->device_id, val); return NULL; } if (strcasecmp(option, "fan") == 0) { if (!setting || !*setting) { sprintf(replybuf, "missing fan value"); return replybuf; } if (set_avalon7_fan(setting)) { sprintf(replybuf, "invalid fan value, valid range 0-100"); return replybuf; } applog(LOG_NOTICE, "%s-%d: Update fan to %d-%d", avalon7->drv->name, avalon7->device_id, opt_avalon7_fan_min, opt_avalon7_fan_max); return NULL; } if (strcasecmp(option, "frequency") == 0) { if (!setting || !*setting) { sprintf(replybuf, "missing frequency value"); return replybuf; } return set_avalon7_device_freq(avalon7, setting); } if (strcasecmp(option, "led") == 0) { int val_led = -1; if (!setting || !*setting) { sprintf(replybuf, "missing module_id setting"); return replybuf; } sscanf(setting, "%d-%d", &val, &val_led); if (val < 1 || val >= AVA7_DEFAULT_MODULARS) { sprintf(replybuf, "invalid module_id: %d, valid range 1-%d", val, AVA7_DEFAULT_MODULARS); return replybuf; } if (!info->enable[val]) { sprintf(replybuf, "the current module was disabled %d", val); return replybuf; } if (val_led == -1) info->led_indicator[val] = !info->led_indicator[val]; else { if (val_led < 0 || val_led > 1) { sprintf(replybuf, "invalid LED status: %d, valid value 0|1", val_led); return replybuf; } if (val_led != info->led_indicator[val]) info->led_indicator[val] = val_led; } applog(LOG_NOTICE, "%s-%d: Module:%d, LED: %s", avalon7->drv->name, avalon7->device_id, val, info->led_indicator[val] ? "on" : "off"); return NULL; } if (strcasecmp(option, "voltage") == 0) { if (!setting || !*setting) { sprintf(replybuf, "missing voltage value"); return replybuf; } return set_avalon7_device_voltage(avalon7, setting); } if (strcasecmp(option, "factory") == 0) { if (!setting || !*setting) { sprintf(replybuf, "missing factory info"); return replybuf; } return set_avalon7_factory_info(avalon7, setting); } if (strcasecmp(option, "reboot") == 0) { if (!setting || !*setting) { sprintf(replybuf, "missing reboot value"); return replybuf; } sscanf(setting, "%d", &val); if (val < 1 || val >= AVA7_DEFAULT_MODULARS) { sprintf(replybuf, "invalid module_id: %d, valid range 1-%d", val, AVA7_DEFAULT_MODULARS); return replybuf; } info->reboot[val] = true; return NULL; } sprintf(replybuf, "Unknown option: %s", option); return replybuf; } static void avalon7_statline_before(char *buf, size_t bufsiz, struct cgpu_info *avalon7) { struct avalon7_info *info = avalon7->device_data; int temp = -273; int fanmin = AVA7_DEFAULT_FAN_MAX; int i, j, k; uint32_t frequency = 0; float ghs_sum = 0, mhsmm = 0; double pass_num = 0.0, fail_num = 0.0; for (i = 1; i < AVA7_DEFAULT_MODULARS; i++) { if (!info->enable[i]) continue; if (fanmin >= info->fan_pct[i]) fanmin = info->fan_pct[i]; if (temp < get_temp_max(info, i)) temp = get_temp_max(info, i); mhsmm = avalon7_hash_cal(avalon7, i); frequency += (mhsmm / (info->asic_count[i] * info->miner_count[i] * 128)); ghs_sum += (mhsmm / 1000); for (j = 0; j < info->miner_count[i]; j++) { for (k = 0; k < info->asic_count[i]; k++) { pass_num += info->get_asic[i][j][k][0]; fail_num += info->get_asic[i][j][k][1]; } } } if (info->mm_count) frequency /= info->mm_count; tailsprintf(buf, bufsiz, "%4dMhz %.2fGHS %2dC %.2f%% %3d%%", frequency, ghs_sum, temp, (fail_num + pass_num) ? fail_num * 100.0 / (fail_num + pass_num) : 0, fanmin); } struct device_drv avalon7_drv = { .drv_id = DRIVER_avalon7, .dname = "avalon7", .name = "AV7", .set_device = avalon7_set_device, .get_api_stats = avalon7_api_stats, .get_statline_before = avalon7_statline_before, .drv_detect = avalon7_detect, .thread_prepare = avalon7_prepare, .hash_work = hash_driver_work, .flush_work = avalon7_sswork_update, .update_work = avalon7_sswork_update, .scanwork = avalon7_scanhash, .max_diff = AVA7_DRV_DIFFMAX, .genwork = true, };