328 lines
10 KiB
Rust
328 lines
10 KiB
Rust
// SPDX-License-Identifier: MIT
|
|
//! One-chain BM13xx mining control built on the SDK hardware backend.
|
|
//! This module never searches for nonces or chooses board safety thresholds.
|
|
|
|
use crate::bm1362;
|
|
use crate::bm1366::{decode_nonce_report, encode_work, ReportError, REPORT_BYTES};
|
|
use crate::pow::verify_sha256_report;
|
|
use crate::{power_decision, HardwareBackend, PowerDecision};
|
|
use std::fmt;
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum ChipModel {
|
|
Bm1362,
|
|
Bm1366,
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
pub enum MinerError<E> {
|
|
Backend(E),
|
|
AlreadyRunning,
|
|
NotRunning,
|
|
Faulted,
|
|
WorkIdInUse(u8),
|
|
UnsafeTemperature(i32),
|
|
InvalidWork,
|
|
InvalidReport(ReportError),
|
|
StaleReport,
|
|
BelowTarget,
|
|
}
|
|
|
|
impl<E: fmt::Display> fmt::Display for MinerError<E> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::Backend(error) => write!(f, "hardware backend: {error}"),
|
|
Self::AlreadyRunning => f.write_str("miner is already running"),
|
|
Self::NotRunning => f.write_str("miner is not running"),
|
|
Self::Faulted => f.write_str("miner shutdown is unconfirmed"),
|
|
Self::WorkIdInUse(id) => write!(f, "BM13xx work ID {id} is still in use"),
|
|
Self::UnsafeTemperature(value) => write!(f, "unsafe temperature: {value} mC"),
|
|
Self::InvalidWork => f.write_str("invalid BM13xx work"),
|
|
Self::InvalidReport(error) => write!(f, "invalid BM13xx report: {error:?}"),
|
|
Self::StaleReport => f.write_str("stale BM13xx work ID"),
|
|
Self::BelowTarget => f.write_str("nonce is below the pool target"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<E: std::error::Error + 'static> std::error::Error for MinerError<E> {}
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub struct ValidShare {
|
|
pub nonce: u32,
|
|
pub work_id: u8,
|
|
pub rolled_version: u32,
|
|
pub hash_le: [u8; 32],
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
struct Work {
|
|
header: [u8; 80],
|
|
target_le: [u8; 32],
|
|
id: u8,
|
|
}
|
|
|
|
pub struct Bm1366Miner<'a, B: HardwareBackend> {
|
|
backend: &'a mut B,
|
|
chip: ChipModel,
|
|
chain: u8,
|
|
sensor: u8,
|
|
fan: u8,
|
|
fan_percent: u8,
|
|
max_temperature_mc: i32,
|
|
running: bool,
|
|
faulted: bool,
|
|
work: [Option<Work>; 32],
|
|
used_work_ids: [bool; 32],
|
|
}
|
|
|
|
impl<'a, B: HardwareBackend> Bm1366Miner<'a, B> {
|
|
/// The caller supplies a threshold validated for this board revision.
|
|
pub fn new(
|
|
backend: &'a mut B,
|
|
chain: u8,
|
|
sensor: u8,
|
|
fan: u8,
|
|
fan_percent: u8,
|
|
max_temperature_mc: i32,
|
|
) -> Option<Self> {
|
|
Self::new_for_chip(
|
|
backend,
|
|
ChipModel::Bm1366,
|
|
chain,
|
|
sensor,
|
|
fan,
|
|
fan_percent,
|
|
max_temperature_mc,
|
|
)
|
|
}
|
|
|
|
/// Select the captured BM1362 or BM1366 work format explicitly.
|
|
pub fn new_for_chip(
|
|
backend: &'a mut B,
|
|
chip: ChipModel,
|
|
chain: u8,
|
|
sensor: u8,
|
|
fan: u8,
|
|
fan_percent: u8,
|
|
max_temperature_mc: i32,
|
|
) -> Option<Self> {
|
|
if fan_percent == 0 || fan_percent > 100 || max_temperature_mc <= 0 {
|
|
return None;
|
|
}
|
|
Some(Self {
|
|
backend,
|
|
chip,
|
|
chain,
|
|
sensor,
|
|
fan,
|
|
fan_percent,
|
|
max_temperature_mc,
|
|
running: false,
|
|
faulted: false,
|
|
work: [None; 32],
|
|
used_work_ids: [false; 32],
|
|
})
|
|
}
|
|
|
|
fn power_off(&mut self) -> Result<(), B::Error> {
|
|
self.work = [None; 32];
|
|
match self.backend.set_psu_enabled(false) {
|
|
Ok(()) => {
|
|
self.running = false;
|
|
self.faulted = false;
|
|
self.used_work_ids = [false; 32];
|
|
Ok(())
|
|
}
|
|
Err(error) => {
|
|
// The backend may have left power on. Drop retries shutdown.
|
|
self.running = true;
|
|
self.faulted = true;
|
|
Err(error)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn check_temperature(&mut self) -> Result<(), MinerError<B::Error>> {
|
|
let value = match self.backend.read_temperature_mc(self.sensor) {
|
|
Ok(value) => value,
|
|
Err(error) => {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
};
|
|
if power_decision(Some(value), self.max_temperature_mc) == PowerDecision::Stop {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::UnsafeTemperature(value));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn start(&mut self) -> Result<(), MinerError<B::Error>> {
|
|
if self.running {
|
|
return Err(MinerError::AlreadyRunning);
|
|
}
|
|
self.power_off().map_err(MinerError::Backend)?;
|
|
self.check_temperature()?;
|
|
self.backend
|
|
.set_fan_target(self.fan, self.fan_percent)
|
|
.map_err(MinerError::Backend)?;
|
|
if let Err(error) = self.backend.set_psu_enabled(true) {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
self.running = true;
|
|
if let Err(error) = self.backend.set_chain_reset(self.chain, true) {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
if let Err(error) = self.backend.set_chain_reset(self.chain, false) {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn stop(&mut self) -> Result<(), B::Error> {
|
|
self.power_off()
|
|
}
|
|
|
|
/// Flush the ASIC's in-flight work before reusing any work IDs. A reset
|
|
/// failure shuts the PSU down because old reports may still arrive.
|
|
pub fn reset_chain(&mut self) -> Result<(), MinerError<B::Error>> {
|
|
if !self.running {
|
|
return Err(MinerError::NotRunning);
|
|
}
|
|
if self.faulted {
|
|
return Err(MinerError::Faulted);
|
|
}
|
|
self.work = [None; 32];
|
|
self.check_temperature()?;
|
|
if let Err(error) = self.backend.set_chain_reset(self.chain, true) {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
if let Err(error) = self.backend.set_chain_reset(self.chain, false) {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
self.used_work_ids = [false; 32];
|
|
Ok(())
|
|
}
|
|
|
|
pub fn submit(
|
|
&mut self,
|
|
header: [u8; 80],
|
|
target_le: [u8; 32],
|
|
work_id: u8,
|
|
) -> Result<(), MinerError<B::Error>> {
|
|
if !self.running {
|
|
return Err(MinerError::NotRunning);
|
|
}
|
|
if self.faulted {
|
|
return Err(MinerError::Faulted);
|
|
}
|
|
self.check_temperature()?;
|
|
let frame = match self.chip {
|
|
ChipModel::Bm1362 => bm1362::encode_work(&header, work_id),
|
|
ChipModel::Bm1366 => encode_work(&header, work_id),
|
|
}
|
|
.ok_or(MinerError::InvalidWork)?;
|
|
let slot = usize::from(work_id >> 3);
|
|
if self.used_work_ids[slot] {
|
|
return Err(MinerError::WorkIdInUse(work_id));
|
|
}
|
|
// A failed send may still have reached the ASIC, so reserve first.
|
|
self.used_work_ids[slot] = true;
|
|
if let Err(error) = self.backend.send_frame(self.chain, &frame) {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
self.work[slot] = Some(Work {
|
|
header,
|
|
target_le,
|
|
id: work_id,
|
|
});
|
|
Ok(())
|
|
}
|
|
|
|
/// Forget prior pool jobs after `clean_jobs`, while leaving the ASIC powered.
|
|
/// Reports already in flight are then classified as stale. Their work IDs
|
|
/// remain reserved until a confirmed chain reset or PSU shutdown.
|
|
pub fn clear_work(&mut self) {
|
|
self.work = [None; 32];
|
|
}
|
|
|
|
pub fn poll(&mut self) -> Result<Option<ValidShare>, MinerError<B::Error>> {
|
|
if !self.running {
|
|
return Err(MinerError::NotRunning);
|
|
}
|
|
if self.faulted {
|
|
return Err(MinerError::Faulted);
|
|
}
|
|
self.check_temperature()?;
|
|
let mut frame = [0_u8; REPORT_BYTES];
|
|
let length = match self.backend.receive_frame(self.chain, &mut frame) {
|
|
Ok(length) => length,
|
|
Err(error) => {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::Backend(error));
|
|
}
|
|
};
|
|
if length == 0 {
|
|
return Ok(None);
|
|
}
|
|
let report = match decode_nonce_report(&frame[..length.min(REPORT_BYTES)]) {
|
|
Ok(report) if length == REPORT_BYTES => report,
|
|
Ok(_) => {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::InvalidReport(ReportError::Length));
|
|
}
|
|
Err(error) => {
|
|
let _ = self.power_off();
|
|
return Err(MinerError::InvalidReport(error));
|
|
}
|
|
};
|
|
let Some(work) = self.work[usize::from(report.work_id >> 3)] else {
|
|
return Err(MinerError::StaleReport);
|
|
};
|
|
if report.work_id != work.id {
|
|
return Err(MinerError::StaleReport);
|
|
}
|
|
let check = verify_sha256_report(
|
|
&work.header,
|
|
report.nonce,
|
|
report.version_field,
|
|
&work.target_le,
|
|
);
|
|
if !check.meets_target {
|
|
return Err(MinerError::BelowTarget);
|
|
}
|
|
Ok(Some(ValidShare {
|
|
nonce: report.nonce,
|
|
work_id: report.work_id,
|
|
rolled_version: check.rolled_version,
|
|
hash_le: check.hash_le,
|
|
}))
|
|
}
|
|
|
|
/// Keep thermal supervision active while pool share replies are pending.
|
|
pub fn supervise(&mut self) -> Result<(), MinerError<B::Error>> {
|
|
if !self.running {
|
|
return Err(MinerError::NotRunning);
|
|
}
|
|
if self.faulted {
|
|
return Err(MinerError::Faulted);
|
|
}
|
|
self.check_temperature()
|
|
}
|
|
}
|
|
|
|
impl<B: HardwareBackend> Drop for Bm1366Miner<'_, B> {
|
|
fn drop(&mut self) {
|
|
if self.running {
|
|
let _ = self.power_off();
|
|
}
|
|
}
|
|
}
|