Generate the output hash for scrypt as well and use the one function to set share_diff.

cgminer.c

@@ -2342,7 +2342,10 @@ static uint64_t share_diff(const struct work *work)
 	uint64_t ret;
 
 	swab256(rhash, work->hash);
-	data64 = (uint64_t *)(rhash + 4);
+	if (opt_scrypt)
+		data64 = (uint64_t *)(rhash + 2);
+	else
+		data64 = (uint64_t *)(rhash + 4);
 	d64 = be64toh(*data64);
 	if (unlikely(!d64))
 		d64 = 1;
@@ -2356,23 +2359,6 @@ static uint64_t share_diff(const struct work *work)
 	return ret;
 }
 
-static uint64_t scrypt_diff(const struct work *work)
-{
-	const uint64_t scrypt_diffone = 0x0000ffff00000000ul;
-	uint64_t d64 = work->outputhash, ret;
-
-	if (unlikely(!d64))
-		d64 = 1;
-	ret = scrypt_diffone / d64;
-	mutex_lock(&control_lock);
-	if (ret > best_diff) {
-		best_diff = ret;
-		suffix_string(best_diff, best_share, 0);
-	}
-	mutex_unlock(&control_lock);
-	return ret;
-}
-
 static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
 {
 	char *hexstr = NULL;
@@ -2383,7 +2369,6 @@ static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
 	struct cgpu_info *cgpu = thr_info[thr_id].cgpu;
 	struct pool *pool = work->pool;
 	int rolltime;
-	uint32_t *hash32;
 	struct timeval tv_submit, tv_submit_reply;
 	char hashshow[64 + 4] = "";
 	char worktime[200] = "";
@@ -2464,26 +2449,20 @@ static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
 
 	if (!QUIET) {
 		int intdiff = floor(work->work_difficulty);
+		char diffdisp[16], *outhash;
+		unsigned char rhash[32];
 		uint64_t sharediff;
-		char diffdisp[16];
-
-		hash32 = (uint32_t *)(work->hash);
-		if (opt_scrypt) {
-			uint64_t outhash;
-
-			scrypt_outputhash(work);
-			sharediff = scrypt_diff(work);
-			suffix_string(sharediff, diffdisp, 0);
 
-			outhash = work->outputhash >> 16;
-			sprintf(hashshow, "%08lx Diff %s/%d", (unsigned long)outhash, diffdisp, intdiff);
-		} else {
-			sharediff = share_diff(work);
-			suffix_string(sharediff, diffdisp, 0);
-
-			sprintf(hashshow, "%08lx Diff %s/%d%s", (unsigned long)(hash32[6]), diffdisp, intdiff,
-				work->block? " BLOCK!" : "");
-		}
+		swab256(rhash, work->hash);
+		if (opt_scrypt)
+			outhash = bin2hex(rhash + 2, 4);
+		else
+			outhash = bin2hex(rhash + 4, 4);
+		sharediff = share_diff(work);
+		suffix_string(sharediff, diffdisp, 0);
+		sprintf(hashshow, "%s Diff %s/%d%s", outhash, diffdisp, intdiff,
+			work->block? " BLOCK!" : "");
+		free(outhash);
 
 		if (opt_worktime) {
 			char workclone[20];
@@ -3095,16 +3074,20 @@ static bool stale_work(struct work *work, bool share)
 
 static void check_solve(struct work *work)
 {
+	if (opt_scrypt)
+		scrypt_outputhash(work);
+	else {
 #ifndef MIPSEB
-	/* This segfaults on openwrt */
-	work->block = regeneratehash(work);
+		/* This segfaults on openwrt */
+		work->block = regeneratehash(work);
+#endif
+	}
 	if (unlikely(work->block)) {
 		work->pool->solved++;
 		found_blocks++;
 		work->mandatory = true;
 		applog(LOG_NOTICE, "Found block for pool %d!", work->pool->pool_no);
 	}
-#endif
 }
 
 static void *submit_work_thread(void *userdata)

miner.h

@@ -972,8 +972,6 @@ struct work {
 	unsigned char	target[32];
 	unsigned char	hash[32];
 
-	uint64_t	outputhash;
-
 	int		rolls;
 
 	dev_blk_ctx	blk;

scrypt.c

@@ -407,16 +407,16 @@ static void scrypt_1024_1_1_256_sp(const uint32_t* input, char* scratchpad, uint
 
 void scrypt_outputhash(struct work *work)
 {
-	uint32_t data[20], ohash[8], rhash[8];
+	uint32_t data[20];
 	char *scratchbuf;
 	uint32_t *nonce = (uint32_t *)(work->data + 76);
+	uint32_t *ohash = (uint32_t *)(work->hash);
 
 	be32enc_vect(data, (const uint32_t *)work->data, 19);
 	data[19] = htobe32(*nonce);
 	scratchbuf = alloca(SCRATCHBUF_SIZE);
 	scrypt_1024_1_1_256_sp(data, scratchbuf, ohash);
-	swap256(rhash, ohash);
-	work->outputhash = be64toh(*((uint64_t *)rhash));
+	flip32(ohash, ohash);
 }
 
 /* Used externally as confirmation of correct OCL code */