Fix bitblock algo code style

algorithm/bitblock.c

@@ -66,8 +66,8 @@ typedef struct {
     sph_echo512_context     echo1;
     sph_hamsi512_context    hamsi1;
     sph_fugue512_context    fugue1;
-	sph_shabal512_context	shabal1;
+    sph_shabal512_context   shabal1;
-	sph_whirlpool_context	whilpool1;
+    sph_whirlpool_context   whirlpool1;
 } Xhash_context_holder;
 
 static Xhash_context_holder base_contexts;
@@ -88,8 +88,8 @@ void init_Bhash_contexts()
     sph_echo512_init(&base_contexts.echo1);
     sph_hamsi512_init(&base_contexts.hamsi1);
     sph_fugue512_init(&base_contexts.fugue1);
-	sph_shabal512_init(&base_contexts.shabal1);
+    sph_shabal512_init(&base_contexts.shabal1);
-	sph_whirlpool_init(&base_contexts.whilpool1);
+    sph_whirlpool_init(&base_contexts.whirlpool1);
 }
 
 /*
@@ -99,10 +99,10 @@ void init_Bhash_contexts()
 static inline void
 be32enc_vect(uint32_t *dst, const uint32_t *src, uint32_t len)
 {
-	uint32_t i;
+    uint32_t i;
 
-	for (i = 0; i < len; i++)
+    for (i = 0; i < len; i++)
-		dst[i] = htobe32(src[i]);
+        dst[i] = htobe32(src[i]);
 }
 
 
@@ -113,7 +113,7 @@ inline void bitblockhash(void *state, const void *input)
     Xhash_context_holder ctx;
 
     uint32_t hashA[16], hashB[16];
-    //blake-bmw-groestl-sken-jh-meccak-luffa-cubehash-shivite-simd-echo
+
     memcpy(&ctx, &base_contexts, sizeof(base_contexts));
 
     sph_blake512 (&ctx.blake1, input, 80);
@@ -155,11 +155,11 @@ inline void bitblockhash(void *state, const void *input)
     sph_fugue512 (&ctx.fugue1, hashB, 64);
     sph_fugue512_close(&ctx.fugue1, hashA);
 
-	sph_shabal512 (&ctx.shabal1, (const unsigned char*)hashA, 64);
+    sph_shabal512 (&ctx.shabal1, (const unsigned char*)hashA, 64);
-	sph_shabal512_close(&ctx.shabal1, hashB);
+    sph_shabal512_close(&ctx.shabal1, hashB);
 
-	sph_whirlpool(&ctx.whilpool1, hashB, 64);
+    sph_whirlpool (&ctx.whirlpool1, hashB, 64);
-	sph_whirlpool_close(&ctx.whilpool1, hashA);
+    sph_whirlpool_close(&ctx.whirlpool1, hashA);
 
     memcpy(state, hashA, 32);
 
@@ -171,83 +171,71 @@ static const uint32_t diff1targ = 0x0000ffff;
 /* Used externally as confirmation of correct OCL code */
 int bitblock_test(unsigned char *pdata, const unsigned char *ptarget, uint32_t nonce)
 {
-	uint32_t tmp_hash7, Htarg = le32toh(((const uint32_t *)ptarget)[7]);
+  uint32_t tmp_hash7, Htarg = le32toh(((const uint32_t *)ptarget)[7]);
-	uint32_t data[20], ohash[8];
+  uint32_t data[20], ohash[8];
-
+
-	be32enc_vect(data, (const uint32_t *)pdata, 19);
+  be32enc_vect(data, (const uint32_t *)pdata, 19);
-	data[19] = htobe32(nonce);
+  data[19] = htobe32(nonce);
-	bitblockhash(ohash, data);
+  bitblockhash(ohash, data);
-	tmp_hash7 = be32toh(ohash[7]);
+  tmp_hash7 = be32toh(ohash[7]);
-
+
-	applog(LOG_DEBUG, "htarget %08lx diff1 %08lx hash %08lx",
+  applog(LOG_DEBUG, "htarget %08lx diff1 %08lx hash %08lx",
-				(long unsigned int)Htarg,
+        (long unsigned int)Htarg,
-				(long unsigned int)diff1targ,
+        (long unsigned int)diff1targ,
-				(long unsigned int)tmp_hash7);
+        (long unsigned int)tmp_hash7);
-	if (tmp_hash7 > diff1targ)
+  if (tmp_hash7 > diff1targ)
-		return -1;
+    return -1;
-	if (tmp_hash7 > Htarg)
+  if (tmp_hash7 > Htarg)
-		return 0;
+    return 0;
-	return 1;
+  return 1;
 }
 
 void bitblock_regenhash(struct work *work)
 {
-        uint32_t data[20];
+  uint32_t data[20];
-        uint32_t *nonce = (uint32_t *)(work->data + 76);
+  uint32_t *nonce = (uint32_t *)(work->data + 76);
-        uint32_t *ohash = (uint32_t *)(work->hash);
+  uint32_t *ohash = (uint32_t *)(work->hash);
-
-        be32enc_vect(data, (const uint32_t *)work->data, 19);
-        data[19] = htobe32(*nonce);
-        bitblockhash(ohash, data);
-}
 
-static inline void be32enc(void *pp, uint32_t x)
+  be32enc_vect(data, (const uint32_t *)work->data, 19);
-{
+  data[19] = htobe32(*nonce);
-	uint8_t *p = (uint8_t *)pp;
+  bitblockhash(ohash, data);
-	p[3] = x & 0xff;
-	p[2] = (x >> 8) & 0xff;
-	p[1] = (x >> 16) & 0xff;
-	p[0] = (x >> 24) & 0xff;
 }
 
 bool scanhash_bitblock(struct thr_info *thr, const unsigned char __maybe_unused *pmidstate,
-		     unsigned char *pdata, unsigned char __maybe_unused *phash1,
+         unsigned char *pdata, unsigned char __maybe_unused *phash1,
-		     unsigned char __maybe_unused *phash, const unsigned char *ptarget,
+         unsigned char __maybe_unused *phash, const unsigned char *ptarget,
-		     uint32_t max_nonce, uint32_t *last_nonce, uint32_t n)
+         uint32_t max_nonce, uint32_t *last_nonce, uint32_t n)
 {
-	uint32_t *nonce = (uint32_t *)(pdata + 76);
+  uint32_t *nonce = (uint32_t *)(pdata + 76);
-	uint32_t data[20];
+  uint32_t data[20];
-	uint32_t tmp_hash7;
+  uint32_t tmp_hash7;
-	uint32_t Htarg = le32toh(((const uint32_t *)ptarget)[7]);
+  uint32_t Htarg = le32toh(((const uint32_t *)ptarget)[7]);
-	bool ret = false;
+  bool ret = false;
-
+
-	be32enc_vect(data, (const uint32_t *)pdata, 19);
+  be32enc_vect(data, (const uint32_t *)pdata, 19);
-
+
-	while(1) {
+  while(1) {
-		uint32_t ostate[8];
+    uint32_t ostate[8];
-		*nonce = ++n;
+    *nonce = ++n;
-		data[19] = (n);
+    data[19] = (n);
-		bitblockhash(ostate, data);
+    bitblockhash(ostate, data);
-		tmp_hash7 = (ostate[7]);
+    tmp_hash7 = (ostate[7]);
-
+
-		applog(LOG_INFO, "data7 %08lx",
+    applog(LOG_INFO, "data7 %08lx",
-					(long unsigned int)data[7]);
+          (long unsigned int)data[7]);
-
+
-		if (unlikely(tmp_hash7 <= Htarg)) {
+    if (unlikely(tmp_hash7 <= Htarg)) {
-			((uint32_t *)pdata)[19] = htobe32(n);
+      ((uint32_t *)pdata)[19] = htobe32(n);
-			*last_nonce = n;
+      *last_nonce = n;
-			ret = true;
+      ret = true;
-			break;
+      break;
-		}
+    }
-
+
-		if (unlikely((n >= max_nonce) || thr->work_restart)) {
+    if (unlikely((n >= max_nonce) || thr->work_restart)) {
-			*last_nonce = n;
+      *last_nonce = n;
-			break;
+      break;
-		}
+    }
-	}
+  }
-
+
-	return ret;
+  return ret;
 }
-
-
-