Core only: Partially move most of opt_scrypt to mining_goal

api.c

@@ -3087,12 +3087,19 @@ static void minecoin(struct io_data *io_data, __maybe_unused SOCKETTYPE c, __may
 			io_add(io_data, buf);
 		}
 		
+		switch (goal->malgo->algo)
+		{
 #ifdef USE_SCRYPT
-		if (opt_scrypt)
-			root = api_add_const(root, "Hash Method", SCRYPTSTR, false);
-		else
+			case POW_SCRYPT:
+				root = api_add_const(root, "Hash Method", SCRYPTSTR, false);
+				break;
 #endif
-			root = api_add_const(root, "Hash Method", SHA256STR, false);
+			case POW_SHA256D:
+				root = api_add_const(root, "Hash Method", SHA256STR, false);
+				break;
+			default:
+				break;
+		}
 
 		cg_rlock(&ch_lock);
 		struct blockchain_info * const blkchain = goal->blkchain;

miner.c

@@ -176,7 +176,6 @@ int opt_g_threads = -1;
 #endif
 #ifdef USE_SCRYPT
 static char detect_algo = 1;
-bool opt_scrypt;
 #else
 static char detect_algo;
 #endif
@@ -993,6 +992,33 @@ static void sharelog(const char*disposition, const struct work*work)
 static void switch_logsize(void);
 #endif
 
+static struct mining_algorithm malgo_sha256d = {
+	.algo = POW_SHA256D,
+	.ui_skip_hash_bytes = 4,
+	.worktime_skip_prevblk_u32 = 1,
+	.reasonable_low_nonce_diff = 1.,
+	
+	.hash_data_f = hash_data,
+};
+
+#ifdef USE_SCRYPT
+static struct mining_algorithm malgo_scrypt = {
+	.algo = POW_SCRYPT,
+	.ui_skip_hash_bytes = 2,
+	.reasonable_low_nonce_diff = 1./0x10000,
+	
+	.hash_data_f = scrypt_hash_data,
+};
+
+static
+const char *set_malgo_scrypt()
+{
+	get_mining_goal("default")->malgo = &malgo_scrypt;
+	return NULL;
+}
+
+#endif
+
 static
 int mining_goals_name_cmp(const struct mining_goal_info * const a, const struct mining_goal_info * const b)
 {
@@ -1034,6 +1060,7 @@ struct mining_goal_info *get_mining_goal(const char * const name)
 			.is_default = !strcmp(name, "default"),
 			.blkchain = blkchain,
 			.current_diff = 0xFFFFFFFFFFFFFFFFULL,
+			.malgo = &malgo_sha256d,
 		};
 		HASH_ADD_STR(mining_goals, name, goal);
 		HASH_SORT(mining_goals, mining_goals_name_cmp);
@@ -2528,7 +2555,7 @@ static struct opt_table opt_config_table[] = {
 		     "Set a time of day in HH:MM to stop mining (will quit without a start time)"),
 #ifdef USE_SCRYPT
 	OPT_WITHOUT_ARG("--scrypt",
-			opt_set_bool, &opt_scrypt,
+	                set_malgo_scrypt, NULL,
 			"Use the scrypt algorithm for mining (non-bitcoin)"),
 #endif
 	OPT_WITH_ARG("--set-device|--set",
@@ -4877,7 +4904,8 @@ void disable_pool(struct pool * const pool, const enum pool_enable enable_status
 static
 void share_result_msg(const struct work *work, const char *disp, const char *reason, bool resubmit, const char *worktime) {
 	struct cgpu_info *cgpu;
-	const unsigned char *hashpart = &work->hash[opt_scrypt ? 26 : 24];
+	const struct mining_algorithm * const malgo = work_mining_algorithm(work);
+	const unsigned char *hashpart = &work->hash[0x1c - malgo->ui_skip_hash_bytes];
 	char shrdiffdisp[ALLOC_H2B_SHORTV];
 	const double tgtdiff = work->work_difficulty;
 	char tgtdiffdisp[ALLOC_H2B_SHORTV];
@@ -5197,10 +5225,12 @@ static bool submit_upstream_work_completed(struct work *work, bool resubmit, str
 			if (work->work_difficulty < 1)
 				diffplaces = 6;
 
+			const struct mining_algorithm * const malgo = work_mining_algorithm(work);
+			const uint8_t * const prevblkhash = &work->data[4];
 			snprintf(worktime, sizeof(worktime),
 				" <-%08lx.%08lx M:%c D:%1.*f G:%02d:%02d:%02d:%1.3f %s (%1.3f) W:%1.3f (%1.3f) S:%1.3f R:%02d:%02d:%02d",
-				(unsigned long)be32toh(*(uint32_t *)&(work->data[opt_scrypt ? 32 : 28])),
-				(unsigned long)be32toh(*(uint32_t *)&(work->data[opt_scrypt ? 28 : 24])),
+				(unsigned long)be32toh(((uint32_t *)prevblkhash)[7 - malgo->worktime_skip_prevblk_u32]),
+				(unsigned long)be32toh(((uint32_t *)prevblkhash)[6 - malgo->worktime_skip_prevblk_u32]),
 				work->getwork_mode, diffplaces, work->work_difficulty,
 				tm_getwork.tm_hour, tm_getwork.tm_min,
 				tm_getwork.tm_sec, getwork_time, workclone,
@@ -5538,7 +5568,9 @@ void setup_benchmark_pool()
 		swork->ntime = 0x7fffffff;
 		timer_unset(&swork->tv_received);
 		memcpy(swork->diffbits, "\x17\0\xff\xff", 4);
-		set_target_to_pdiff(swork->target, opt_scrypt ? (1./0x10000) : 1.);
+		const struct mining_goal_info * const goal = get_mining_goal("default");
+		const struct mining_algorithm * const malgo = goal->malgo;
+		set_target_to_pdiff(swork->target, malgo->reasonable_low_nonce_diff);
 		pool->nonce2sz = swork->n2size = GBT_XNONCESZ;
 		pool->nonce2 = 0;
 	}
@@ -10149,12 +10181,8 @@ void inc_hw_errors3(struct thr_info *thr, const struct work *work, const uint32_
 
 void work_hash(struct work * const work)
 {
-#ifdef USE_SCRYPT
-	if (opt_scrypt)
-		scrypt_hash_data(work->hash, work->data);
-	else
-#endif
-		hash_data(work->hash, work->data);
+	const struct mining_algorithm * const malgo = work_mining_algorithm(work);
+	malgo->hash_data_f(work->hash, work->data);
 }
 
 static
@@ -13213,7 +13241,7 @@ int main(int argc, char *argv[])
 #ifdef USE_SCRYPT
 	if (detect_algo == 1 && !opt_scrypt) {
 		applog(LOG_NOTICE, "Detected scrypt algorithm");
-		opt_scrypt = true;
+		set_malgo_scrypt();
 	}
 #endif
 	detect_algo = 0;

miner.h

@@ -1122,6 +1122,15 @@ struct blockchain_info {
 	char currentblk_first_seen_time_str[0x20];  // was global blocktime
 };
 
+struct mining_algorithm {
+	enum pow_algorithm algo;
+	uint8_t ui_skip_hash_bytes;
+	uint8_t worktime_skip_prevblk_u32;
+	float reasonable_low_nonce_diff;
+	
+	void (*hash_data_f)(void *digest, const void *data);
+};
+
 struct mining_goal_info {
 	unsigned id;
 	char *name;
@@ -1131,6 +1140,7 @@ struct mining_goal_info {
 	
 	bytes_t *generation_script;  // was opt_coinbase_script
 	
+	struct mining_algorithm *malgo;
 	double current_diff;
 	char current_diff_str[ALLOC_H2B_SHORTV];  // was global block_diff
 	char net_hashrate[ALLOC_H2B_SHORT];
@@ -1156,7 +1166,7 @@ extern struct thr_info *control_thr;
 extern struct thr_info **mining_thr;
 extern struct cgpu_info gpus[MAX_GPUDEVICES];
 #ifdef USE_SCRYPT
-extern bool opt_scrypt;
+#define opt_scrypt (get_mining_goal("default")->malgo->algo == POW_SCRYPT)
 #else
 #define opt_scrypt (0)
 #endif
@@ -1576,6 +1586,16 @@ extern const char *bfg_workpadding_bin;
 extern void set_simple_ntime_roll_limit(struct ntime_roll_limits *, uint32_t ntime_base, int ntime_roll, const struct timeval *tvp_ref);
 extern void work_set_simple_ntime_roll_limit(struct work *, int ntime_roll, const struct timeval *tvp_ref);
 extern int work_ntime_range(struct work *, const struct timeval *tvp_earliest, const struct timeval *tvp_latest, int desired_roll);
+
+static inline
+const struct mining_algorithm *work_mining_algorithm(const struct work * const work)
+{
+	const struct pool * const pool = work->pool;
+	const struct mining_goal_info * const goal = pool->goal;
+	const struct mining_algorithm * const malgo = goal->malgo;
+	return malgo;
+}
+
 extern void work_hash(struct work *);
 
 #define NTIME_DATA_OFFSET  0x44

scrypt.c

@@ -489,15 +489,15 @@ void scrypt_regenhash(struct work *work)
 }
 
 /* Used by test_nonce functions */
-void scrypt_hash_data(unsigned char * const out_hash, const unsigned char * const pdata)
+void scrypt_hash_data(void * const out_hash, const void * const pdata)
 {
 	uint32_t data[20], ohash[8];
 	char *scratchbuf;
 
-	be32enc_vect(data, (const uint32_t *)pdata, 20);
+	be32enc_vect(data, pdata, 20);
 	scratchbuf = alloca(SCRATCHBUF_SIZE);
 	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash);
-	swap32tobe((void*)out_hash, ohash, 32/4);
+	swap32tobe(out_hash, ohash, 32/4);
 }
 
 bool scanhash_scrypt(struct thr_info *thr, const unsigned char __maybe_unused *pmidstate,

scrypt.h

@@ -7,7 +7,7 @@
 
 #ifdef USE_SCRYPT
 extern void test_scrypt(void);
-extern void scrypt_hash_data(unsigned char *out_hash, const unsigned char *data);
+extern void scrypt_hash_data(void *digest, const void *data);
 extern void scrypt_regenhash(struct work *work);
 
 #else /* USE_SCRYPT */

util.c

@@ -790,7 +790,7 @@ char *ucs2_to_utf8_dup(uint16_t * const in, size_t sz)
 	return out;
 }
 
-void hash_data(unsigned char *out_hash, const unsigned char *data)
+void hash_data(void *out_hash, const void *data)
 {
 	unsigned char blkheader[80];
 	
@@ -2635,6 +2635,8 @@ out:
 
 static bool parse_diff(struct pool *pool, json_t *val)
 {
+	const struct mining_goal_info * const goal = pool->goal;
+	const struct mining_algorithm * const malgo = goal->malgo;
 	double diff;
 
 	diff = json_number_value(json_array_get(val, 0));
@@ -2648,7 +2650,7 @@ static bool parse_diff(struct pool *pool, json_t *val)
 		diff = bdiff_to_pdiff(diff);
 	}
 	
-	if ((!opt_scrypt) && diff < 1 && diff > 0.999)
+	if (malgo->algo == POW_SHA256D && diff < 1 && diff > 0.999)
 		diff = 1;
 	
 #ifdef USE_SCRYPT
@@ -2666,7 +2668,7 @@ static bool parse_diff(struct pool *pool, json_t *val)
 	// Diff 16 at 1.15 Gh/s = 1 share / 60s
 	// Diff 16 at 7.00 Gh/s = 1 share / 10s
 
-	if (opt_scrypt && (diff >= minimum_broken_scrypt_diff))
+	if (malgo->algo == POW_SCRYPT && (diff >= minimum_broken_scrypt_diff))
 		diff /= broken_scrypt_diff_multiplier;
 #endif
 

util.h

@@ -192,7 +192,7 @@ extern char *ucs2_to_utf8_dup(uint16_t *in, size_t sz);
 }while(0)
 
 extern void gen_hash(unsigned char *data, unsigned char *hash, int len);
-extern void hash_data(unsigned char *out_hash, const unsigned char *data);
+extern void hash_data(void *digest, const void *data);
 extern void real_block_target(unsigned char *target, const unsigned char *data);
 extern bool hash_target_check(const unsigned char *hash, const unsigned char *target);
 extern bool hash_target_check_v(const unsigned char *hash, const unsigned char *target);