thodg/cgminer

diff --git a/driver-icarus.c b/driver-icarus.c
index 635531c..d51a96d 100644
--- a/driver-icarus.c
+++ b/driver-icarus.c
@@ -316,12 +316,11 @@ typedef enum {
 	NONCE_GET_TASK_CMD,
 } NONCE_COMMAND;
 
-typedef struct NONCE_DATA
-{
-int chip_no ;
-unsigned int task_no ;
-unsigned char work_state;
-int cmd_value;
+typedef struct NONCE_DATA {
+	int chip_no ;
+	unsigned int task_no ;
+	unsigned char work_state;
+	int cmd_value;
 }NONCE_DATA;
 
 
@@ -332,23 +331,21 @@ typedef enum {
 	ROCKMINER_MAX
 } ROCKMINER_PRODUCT_T;
 
-typedef struct ROCKMINER_CHIP_INFO
-{
-unsigned char freq;
-int error_cnt;
-time_t last_received_task_complete_time;
+typedef struct ROCKMINER_CHIP_INFO {
+	unsigned char freq;
+	int error_cnt;
+	time_t last_received_task_complete_time;
 }ROCKMINER_CHIP_INFO;
 
-typedef struct ROCKMINER_DEVICE_INFO
-{
-unsigned char detect_chip_no;
-unsigned char chip_max;
-unsigned char product_id;
-float min_frq;
-float def_frq;
-float max_frq;
-ROCKMINER_CHIP_INFO chip[MAX_CHIP_NUM];
-time_t dev_detect_time;
+typedef struct ROCKMINER_DEVICE_INFO {
+	unsigned char detect_chip_no;
+	unsigned char chip_max;
+	unsigned char product_id;
+	float min_frq;
+	float def_frq;
+	float max_frq;
+	ROCKMINER_CHIP_INFO chip[MAX_CHIP_NUM];
+	time_t dev_detect_time;
 }ROCKMINER_DEVICE_INFO;
 
 ROCKMINER_DEVICE_INFO rmdev[MAX_DEVICE_NUM];
@@ -1039,10 +1036,10 @@ static bool set_anu_freq(struct cgpu_info *icarus, struct ICARUS_INFO *info)
 static void rock_init_last_received_task_complete_time(uint32_t dev_id)
 {
 	int i;
-	if(opt_rock_freq<rmdev[dev_id].min_frq||(opt_rock_freq>rmdev[dev_id].max_frq))
-			opt_rock_freq =rmdev[dev_id].def_frq;
-	for (i = 0; i < MAX_CHIP_NUM; ++i)
-	{
+
+	if (opt_rock_freq < rmdev[dev_id].min_frq || (opt_rock_freq > rmdev[dev_id].max_frq))
+		opt_rock_freq =rmdev[dev_id].def_frq;
+	for (i = 0; i < MAX_CHIP_NUM; ++i) {
 		rmdev[dev_id].chip[i].last_received_task_complete_time = time(NULL);
 		rmdev[dev_id].chip[i].freq = opt_rock_freq/10 - 1;
 		rmdev[dev_id].chip[i].error_cnt= 0;
@@ -1050,48 +1047,48 @@ static void rock_init_last_received_task_complete_time(uint32_t dev_id)
 	rmdev[dev_id].dev_detect_time = time(NULL);
 }
 
-struct work *g_work[MAX_DEVICE_NUM][MAX_CHIP_NUM][MAX_WORK_BUFFER_SIZE];
+static struct work *g_work[MAX_DEVICE_NUM][MAX_CHIP_NUM][MAX_WORK_BUFFER_SIZE];
 
-void clear_chip_busy(int device_id)
+static void clear_chip_busy(int device_id)
 {
-	memset(&(g_work[device_id][0]), 0, (sizeof(g_work)/MAX_DEVICE_NUM));
+	memset(&(g_work[device_id][0]), 0, (sizeof(g_work) / MAX_DEVICE_NUM));
 }
 
-void rock_print_work_data(struct ICARUS_WORK *p_workdata)
+static void rock_print_work_data(struct ICARUS_WORK *p_workdata)
 {
 	char *ob_hex = NULL;
+
 	opt_debug = ROCKMINER_PRINT_DEBUG;
 	if (opt_debug) {
 		ob_hex = bin2hex((void *)(p_workdata), sizeof(*p_workdata));
 		applog(LOG_WARNING, "sent %s", ob_hex);
 		free(ob_hex);
-
-        rev((void *)(&(p_workdata->midstate)), ICARUS_MIDSTATE_SIZE);
-    	rev((void *)(&(p_workdata->work)), ICARUS_WORK_SIZE);
-    	ob_hex = bin2hex((void *)(p_workdata), sizeof(*p_workdata));
-    	applog(LOG_WARNING, "revert sent %s", ob_hex);
-    	free(ob_hex);
+		rev((void *)(&(p_workdata->midstate)), ICARUS_MIDSTATE_SIZE);
+		rev((void *)(&(p_workdata->work)), ICARUS_WORK_SIZE);
+		ob_hex = bin2hex((void *)(p_workdata), sizeof(*p_workdata));
+		applog(LOG_WARNING, "revert sent %s", ob_hex);
+		free(ob_hex);
 	}
 }
 
 bool icarus_get_device_id(struct cgpu_info *cgpu);
 
+// Block 171874 nonce = (0xa2870100) = 0x000187a2
+// N.B. golden_ob MUST take less time to calculate
+//	than the timeout set in icarus_open()
+//	This one takes ~0.53ms on Rev3 Icarus
+static const char golden_ob[] =
+	"4679ba4ec99876bf4bfe086082b40025"
+	"4df6c356451471139a3afa71e48f544a"
+	"00000000000000000000000000000000"
+	"aa1ff05587320b1a1426674f2fa722ce";
+
 static struct cgpu_info *icarus_detect_one(struct libusb_device *dev, struct usb_find_devices *found)
 {
 	int this_option_offset = ++option_offset;
 	struct ICARUS_INFO *info;
 	struct timeval tv_start, tv_finish;
 
-	// Block 171874 nonce = (0xa2870100) = 0x000187a2
-	// N.B. golden_ob MUST take less time to calculate
-	//	than the timeout set in icarus_open()
-	//	This one takes ~0.53ms on Rev3 Icarus
-	const char golden_ob[] =
-		"4679ba4ec99876bf4bfe086082b40025"
-		"4df6c356451471139a3afa71e48f544a"
-		"00000000000000000000000000000000"
-		"0000000087320b1a1426674f2fa722ce";
-
 	const char golden_nonce[] = "000187a2";
 	const uint32_t golden_nonce_val = 0x000187a2;
 	unsigned char nonce_bin[ICARUS_READ_SIZE];
@@ -1371,16 +1368,6 @@ static struct cgpu_info *rock_detect_one(struct libusb_device *dev, struct usb_f
 	int opt_debug = ROCKMINER_PRINT_DEBUG;
 	char *ob_hex = NULL;
 
-	// Block 171874 nonce = (0xa2870100) = 0x000187a2
-	// N.B. golden_ob MUST take less time to calculate
-	//	than the timeout set in icarus_open()
-	//	This one takes ~0.53ms on Rev3 Icarus
-	const char golden_ob[] =
-		"4679ba4ec99876bf4bfe086082b40025"
-		"4df6c356451471139a3afa71e48f544a"
-		"00000000000000000000000000000000"
-		"aa1ff05587320b1a1426674f2fa722ce";
-
 	const char golden_nonce[] = "000187a2";
 	const uint32_t golden_nonce_val = 0x000187a2;
 	unsigned char nonce_bin[ROCK_READ_SIZE];
@@ -1447,62 +1434,55 @@ static struct cgpu_info *rock_detect_one(struct libusb_device *dev, struct usb_f
 		workdata.unused[ICARUS_UNUSED_SIZE - 3] = opt_rock_freq/10 - 1;
 		workdata.unused[ICARUS_UNUSED_SIZE - 2] = (MAX_TRIES-1-tries);
 		rmdev[dev_id].detect_chip_no ++;
-			if(rmdev[dev_id].detect_chip_no >=MAX_TRIES )
-				rmdev[dev_id].detect_chip_no = 0;
+		if(rmdev[dev_id].detect_chip_no >=MAX_TRIES )
+			rmdev[dev_id].detect_chip_no = 0;
 		//g_detect_chip_no[dev_id] = (g_detect_chip_no[dev_id] + 1) & MAX_CHIP_NUM;
 
 		err = usb_write_ii(icarus, info->intinfo,
 				   (char *)(&workdata), sizeof(workdata), &amount, C_SENDWORK);
 		rock_print_work_data(&workdata);
 		if (err != LIBUSB_SUCCESS || amount != sizeof(workdata))
-		continue;
+			continue;
 
 		memset(nonce_bin, 0, sizeof(nonce_bin));
 		ret = icarus_get_nonce(icarus, nonce_bin, &tv_start, &tv_finish, NULL, 100);
 #if ROCKMINER_PRINT_DEBUG
 		applog(LOG_WARNING, "Rockminer nonce_bin: %02X, %02X, %02X, %02X, %02X, %02X, %02X, %02X", nonce_bin[0], nonce_bin[1], nonce_bin[2], nonce_bin[3], nonce_bin[4], nonce_bin[5], nonce_bin[6], nonce_bin[7]);
 #endif
-		if (ret != ICA_NONCE_OK)
-		{
+		if (ret != ICA_NONCE_OK) {
 #if ROCKMINER_PRINT_DEBUG
-		applog(LOG_WARNING, "detect_one get_gold_nonce error, tries = %d.\r\n", tries);
+			applog(LOG_WARNING, "detect_one get_gold_nonce error, tries = %d.\r\n", tries);
 #endif
 			continue;
 		}
 
 		//device max chip
-		if((nonce_bin[NONCE_CHIP_NO_OFFSET]&RM_PRODUCT_MASK)==RM_PRODUCT_T1)
-		{
+		if((nonce_bin[NONCE_CHIP_NO_OFFSET]&RM_PRODUCT_MASK) == RM_PRODUCT_T1) {
 			rmdev[dev_id].product_id = ROCKMINER_T1;
 			rmdev[dev_id].chip_max = 24;
 			rmdev[dev_id].min_frq = 200;
 			rmdev[dev_id].def_frq = 280;
 			rmdev[dev_id].max_frq = 320;
-		}
-		else
-		{
+		} else {
 			rmdev[dev_id].product_id= ROCKMINER_RBOX;
 			rmdev[dev_id].chip_max = 4;
 			rmdev[dev_id].min_frq = 200;
 			rmdev[dev_id].def_frq = 270;
 			rmdev[dev_id].max_frq = 290;
 		}
-		nonce_data.chip_no = nonce_bin[NONCE_CHIP_NO_OFFSET]&RM_CHIP_MASK;
+		nonce_data.chip_no = nonce_bin[NONCE_CHIP_NO_OFFSET] & RM_CHIP_MASK;
 		if (nonce_data.chip_no >= rmdev[dev_id].chip_max)
-		{
 			nonce_data.chip_no = 0;
-		}
 
-		nonce_data.cmd_value = nonce_bin[NONCE_TASK_CMD_OFFSET]&RM_CMD_MASK;
-		if (nonce_data.cmd_value == NONCE_TASK_COMPLETE_CMD)
-		{
+		nonce_data.cmd_value = nonce_bin[NONCE_TASK_CMD_OFFSET] & RM_CMD_MASK;
+		if (nonce_data.cmd_value == NONCE_TASK_COMPLETE_CMD) {
 #if ROCKMINER_PRINT_DEBUG
 			applog(LOG_WARNING, "complete g_detect_chip_no: %d", rmdev[dev_id].detect_chip_no);
 #endif
-		workdata.unused[ICARUS_UNUSED_SIZE - 3] = opt_rock_freq/10 - 1;
-			workdata.unused[ICARUS_UNUSED_SIZE - 2] =  rmdev[dev_id].detect_chip_no;
+			workdata.unused[ICARUS_UNUSED_SIZE - 3] = opt_rock_freq / 10 - 1;
+			workdata.unused[ICARUS_UNUSED_SIZE - 2] = rmdev[dev_id].detect_chip_no;
 			rmdev[dev_id].detect_chip_no ++;
-			if(rmdev[dev_id].detect_chip_no>=MAX_TRIES)
+			if(rmdev[dev_id].detect_chip_no >= MAX_TRIES)
 				rmdev[dev_id].detect_chip_no = 0;
 
 			err = usb_write_ii(icarus, info->intinfo,
@@ -1522,8 +1502,7 @@ static struct cgpu_info *rock_detect_one(struct libusb_device *dev, struct usb_f
 		applog(LOG_WARNING, "Rockminer nonce: %08X", nonce);
 #endif
 		correction_times = 0;
-		while(correction_times<NONCE_CORRECTION_TIMES)
-		{
+		while(correction_times < NONCE_CORRECTION_TIMES) {
 			nonce_hex = bin2hex(nonce_bin, 4);
 			if (golden_nonce_val == nonce + correction_value[correction_times]) {
 				clear_chip_busy(dev_id);
@@ -1542,25 +1521,21 @@ static struct cgpu_info *rock_detect_one(struct libusb_device *dev, struct usb_f
 						icarus->device_path, nonce_hex, golden_nonce);
 				}
 
-				if(nonce == 0)
-				{
+				if (nonce == 0)
 					break;
-				}
 			}
 			free(nonce_hex);
 			correction_times++;
 		}
 
 #if ROCKMINER_PRINT_DEBUG
-			if(correction_times > 0 )
-			{
+			if(correction_times > 0 ) {
 				if (correction_times < NONCE_CORRECTION_TIMES)
-				applog(LOG_WARNING, "Rockminer correction the Golden nonce success %s%d[%d]=%d",icarus->drv->name, icarus->device_id,chip_no,correction_times);
+					applog(LOG_WARNING, "Rockminer correction the Golden nonce success %s%d[%d]=%d",icarus->drv->name, icarus->device_id,chip_no,correction_times);
 				else
-				applog(LOG_WARNING, "Rockminer correction the Golden nonce fail %s%d[%d]=%d",icarus->drv->name, icarus->device_id,chip_no,correction_times);
+					applog(LOG_WARNING, "Rockminer correction the Golden nonce fail %s%d[%d]=%d",icarus->drv->name, icarus->device_id,chip_no,correction_times);
 			}
 #endif
-
 	}
 
 	if (!ok)
@@ -1663,17 +1638,12 @@ void rock_send_task(unsigned char chip_no, unsigned int current_task_id, struct 
 	applog(LOG_WARNING, "thr_info id:%d, device_thread:%d, icarus cgminer_id: %d, device_id: %d.", thr->id, thr->device_thread, icarus->cgminer_id, icarus->device_id);
 	applog(LOG_WARNING, "::::::::::::::g_work[%d][%d][%d] = 0x%x", dev_id, chip_no, current_task_id, (int)g_work[dev_id][chip_no][current_task_id]);
 #endif
-	if (g_work[dev_id][chip_no][current_task_id] == NULL)
-	{
+	if (g_work[dev_id][chip_no][current_task_id] == NULL) {
 		work = get_work(thr, thr->id);
 		if (work == NULL)
-		{
 			return;
-		}
 		g_work[dev_id][chip_no][current_task_id] = work;
-	}
-	else
-	{
+	} else {
 		work = g_work[dev_id][chip_no][current_task_id];
 #if ROCKMINER_PRINT_DEBUG
 		applog(LOG_WARNING, "::resend work");
@@ -1689,10 +1659,8 @@ void rock_send_task(unsigned char chip_no, unsigned int current_task_id, struct 
 	memcpy(&(workdata.midstate), work->midstate, ICARUS_MIDSTATE_SIZE);
 	memcpy(&(workdata.work), work->data + ICARUS_WORK_DATA_OFFSET, ICARUS_WORK_SIZE);
 	workdata.unused[ICARUS_UNUSED_SIZE - 4] = 0xaa;
-	if((rmdev[dev_id].chip[chip_no].freq>(rmdev[dev_id].max_frq/10-1))||(rmdev[dev_id].chip[chip_no].freq<(rmdev[dev_id].min_frq/10-1)))
-	{
+	if ((rmdev[dev_id].chip[chip_no].freq > (rmdev[dev_id].max_frq / 10 - 1)) || (rmdev[dev_id].chip[chip_no].freq < (rmdev[dev_id].min_frq / 10 - 1)))
 		rock_init_last_received_task_complete_time(dev_id);
-	}
 	workdata.unused[ICARUS_UNUSED_SIZE - 3] = rmdev[dev_id].chip[chip_no].freq; //icarus->freq/10 - 1; ;
 	workdata.unused[ICARUS_UNUSED_SIZE - 2] = chip_no ;
 	workdata.unused[ICARUS_UNUSED_SIZE - 1] = 0x55;
@@ -1705,18 +1673,9 @@ void rock_send_task(unsigned char chip_no, unsigned int current_task_id, struct 
 		free(ob_hex);
 	}
 
-#ifndef ROCKMINER
-	rev((void *)(&(workdata.midstate)), ICARUS_MIDSTATE_SIZE);
-	rev((void *)(&(workdata.work)), ICARUS_WORK_SIZE);
-
-	if (info->speed_next_work || info->flash_next_work)
-		//cmr2_commands(icarus);
-#endif
-
 	// We only want results for the work we are about to send
 	usb_buffer_clear(icarus);
 
-
 	err = usb_write_ii(icarus, info->intinfo, (char *)(&workdata), sizeof(workdata), &amount, C_SENDWORK);
 
 	if (err < 0 || amount != sizeof(workdata)) {
@@ -1725,8 +1684,7 @@ void rock_send_task(unsigned char chip_no, unsigned int current_task_id, struct 
 		dev_error(icarus, REASON_DEV_COMMS_ERROR);
 		icarus_initialise(icarus, info->baud);
 
-		if(g_work[dev_id][chip_no][current_task_id])
-		{
+		if(g_work[dev_id][chip_no][current_task_id]) {
 			free_work(g_work[dev_id][chip_no][current_task_id]);
 			g_work[dev_id][chip_no][current_task_id] = NULL;
 		}
@@ -1741,12 +1699,12 @@ void rock_send_task(unsigned char chip_no, unsigned int current_task_id, struct 
 			icarus->drv->name, icarus->device_id, ob_hex);
 		free(ob_hex);
 
-        rev((void *)(&(workdata.midstate)), ICARUS_MIDSTATE_SIZE);
-    	rev((void *)(&(workdata.work)), ICARUS_WORK_SIZE);
-    	ob_hex = bin2hex((void *)(&workdata), sizeof(workdata));
-    	applog(LOG_WARNING, "%s%d: revert sent %s",
-    		icarus->drv->name, icarus->device_id, ob_hex);
-    	free(ob_hex);
+		rev((void *)(&(workdata.midstate)), ICARUS_MIDSTATE_SIZE);
+		rev((void *)(&(workdata.work)), ICARUS_WORK_SIZE);
+		ob_hex = bin2hex((void *)(&workdata), sizeof(workdata));
+		applog(LOG_WARNING, "%s%d: revert sent %s",
+			icarus->drv->name, icarus->device_id, ob_hex);
+		free(ob_hex);
 	}
 
 	return;
@@ -2057,11 +2015,9 @@ static int64_t rock_scanwork(struct thr_info *thr)
 	elapsed.tv_sec = elapsed.tv_usec = 0;
 
 
-	for (chip_no = 0; chip_no < rmdev[dev_id].chip_max; chip_no++)
-	{
+	for (chip_no = 0; chip_no < rmdev[dev_id].chip_max; chip_no++) {
 		recv_time = time(NULL);
-		if (recv_time > rmdev[dev_id].chip[chip_no].last_received_task_complete_time + 1)
-		{
+		if (recv_time > rmdev[dev_id].chip[chip_no].last_received_task_complete_time + 1) {
 #if NONCE_TEST
 			applog(LOG_WARNING, ":::chip_no error = %d nonce timeout", chip_no);
 #endif
@@ -2071,34 +2027,30 @@ static int64_t rock_scanwork(struct thr_info *thr)
 		}
 	}
 
-	/* Icarus will return 4 bytes (ICARUS_READ_SIZE) nonces or nothing */
 	memset(nonce_bin, 0, sizeof(nonce_bin));
 	ret = icarus_get_nonce(icarus, nonce_bin, &tv_start, &tv_finish, thr, 3000);//info->read_time);
 #if ROCKMINER_PRINT_DEBUG
 	applog(LOG_WARNING, "Rockminer nonce_bin: ret = %d. %02X, %02X, %02X, %02X, %02X, %02X, %02X, %02X", ret, nonce_bin[0], nonce_bin[1], nonce_bin[2], nonce_bin[3], nonce_bin[4], nonce_bin[5], nonce_bin[6], nonce_bin[7]);
 #endif
-	if((nonce_bin[NONCE_CHIP_NO_OFFSET]&RM_PRODUCT_MASK)==RM_PRODUCT_T1)
-		{
-			rmdev[dev_id].product_id = ROCKMINER_T1;
-			rmdev[dev_id].chip_max = 24;
-			rmdev[dev_id].min_frq = 200;
-			rmdev[dev_id].def_frq = 280;
-			rmdev[dev_id].max_frq = 320;
-		}
-		else
-		{
-			rmdev[dev_id].product_id= ROCKMINER_RBOX;
-			rmdev[dev_id].chip_max = 4;
-			rmdev[dev_id].min_frq = 200;
-			rmdev[dev_id].def_frq = 270;
-			rmdev[dev_id].max_frq = 290;
-		}
-	nonce_data.chip_no = nonce_bin[NONCE_CHIP_NO_OFFSET]&RM_CHIP_MASK;
-	if(nonce_data.chip_no>=rmdev[dev_id].chip_max)
-		nonce_data.chip_no=0;
-	nonce_data.task_no = nonce_bin[NONCE_TASK_NO_OFFSET]>=2?0:nonce_bin[NONCE_TASK_NO_OFFSET];
-	nonce_data.cmd_value = nonce_bin[NONCE_TASK_CMD_OFFSET]&RM_CMD_MASK;
-	nonce_data.work_state = nonce_bin[NONCE_TASK_CMD_OFFSET]&RM_STATUS_MASK;
+	if((nonce_bin[NONCE_CHIP_NO_OFFSET]&RM_PRODUCT_MASK)==RM_PRODUCT_T1) {
+		rmdev[dev_id].product_id = ROCKMINER_T1;
+		rmdev[dev_id].chip_max = 24;
+		rmdev[dev_id].min_frq = 200;
+		rmdev[dev_id].def_frq = 280;
+		rmdev[dev_id].max_frq = 320;
+	} else {
+		rmdev[dev_id].product_id= ROCKMINER_RBOX;
+		rmdev[dev_id].chip_max = 4;
+		rmdev[dev_id].min_frq = 200;
+		rmdev[dev_id].def_frq = 270;
+		rmdev[dev_id].max_frq = 290;
+	}
+	nonce_data.chip_no = nonce_bin[NONCE_CHIP_NO_OFFSET] & RM_CHIP_MASK;
+	if(nonce_data.chip_no >= rmdev[dev_id].chip_max)
+		nonce_data.chip_no = 0;
+	nonce_data.task_no = nonce_bin[NONCE_TASK_NO_OFFSET] >= 2 ? 0: nonce_bin[NONCE_TASK_NO_OFFSET];
+	nonce_data.cmd_value = nonce_bin[NONCE_TASK_CMD_OFFSET] & RM_CMD_MASK;
+	nonce_data.work_state = nonce_bin[NONCE_TASK_CMD_OFFSET] & RM_STATUS_MASK;
 #if ROCKMINER_PRINT_DEBUG
 	if(nonce_data.work_state == 2)
 		applog(LOG_WARNING, "Temperature of Device is too hign to work!");
@@ -2108,30 +2060,25 @@ static int64_t rock_scanwork(struct thr_info *thr)
 	if (icarus->temp == 128)
 		icarus->temp = 0;
 
-	if (nonce_data.cmd_value == NONCE_TASK_COMPLETE_CMD)
-	{
+	if (nonce_data.cmd_value == NONCE_TASK_COMPLETE_CMD) {
 		rmdev[dev_id].chip[nonce_data.chip_no].last_received_task_complete_time = time(NULL);
 
-		if (g_work[dev_id][nonce_data.chip_no][nonce_data.task_no])
-		{
+		if (g_work[dev_id][nonce_data.chip_no][nonce_data.task_no]) {
 			free_work(g_work[dev_id][nonce_data.chip_no][nonce_data.task_no]);
 			g_work[dev_id][nonce_data.chip_no][nonce_data.task_no] = NULL;
 		}
 #ifdef NONCE_TEST// ROCKMINER_PRINT_DEBUG
 			chip_work_conunts[nonce_data.chip_no] ++;
 #endif
-
 		goto out;
 	}
 
-	if (nonce_data.cmd_value == NONCE_GET_TASK_CMD)
-	{
+	if (nonce_data.cmd_value == NONCE_GET_TASK_CMD) {
 		rock_send_task(nonce_data.chip_no, nonce_data.task_no, thr);
 		goto out;
 	}
 
-	if (ret == ICA_NONCE_TIMEOUT)
-	{
+	if (ret == ICA_NONCE_TIMEOUT) {
 #if ROCKMINER_PRINT_DEBUG
 		applog(LOG_WARNING, "chip_no = %d nonce timeout, ret = %d", nonce_data.chip_no, ret);
 #endif
@@ -2144,9 +2091,7 @@ static int64_t rock_scanwork(struct thr_info *thr)
 
 	work = g_work[dev_id][nonce_data.chip_no][nonce_data.task_no];
 	if (work == NULL)
-	{
 		goto out;
-	}
 
 	if (ret == ICA_NONCE_ERROR)
 		goto out;
@@ -2185,97 +2130,78 @@ static int64_t rock_scanwork(struct thr_info *thr)
 #endif
 
 	recv_time = time(NULL);
-	if((recv_time-rmdev[dev_id].dev_detect_time )>=60)//device_chip_max[device_id]
-		{
+	if ((recv_time-rmdev[dev_id].dev_detect_time ) >= 60) {//device_chip_max[device_id]
 		unsigned char i;
+
 		rmdev[dev_id].dev_detect_time  = recv_time;
 #ifdef NONCE_TEST// ROCKMINER_PRINT_DEBUG
 		applog(LOG_WARNING, "AMU%d Freq: %d0MHz/ %d0MHz/ %d0MHz/ %d0MHz ",dev_id,rmdev[dev_id].chip[0].freq+1,rmdev[dev_id].chip[1].freq+1,rmdev[dev_id].chip[2].freq+1,rmdev[dev_id].chip[3].freq+1);
 #endif
-			for (i = 0; i  < rmdev[dev_id].chip_max; i ++)
-			{
+			for (i = 0; i  < rmdev[dev_id].chip_max; i ++) {
 #ifdef NONCE_TEST// ROCKMINER_PRINT_DEBUG
-			applog(LOG_WARNING, "AMU%d Chip[%d] nonce=%d/%d/%d,freq:%d0MHz, ",dev_id,i,rmdev[dev_id].chip[i].error_cnt,chip_nonce_conunts[i],chip_work_conunts[i],rmdev[dev_id].chip[i].freq+1);
-			chip_nonce_conunts[i] = 0;
-			chip_work_conunts[i] = 0;
+				applog(LOG_WARNING, "AMU%d Chip[%d] nonce=%d/%d/%d,freq:%d0MHz, ",dev_id,i,rmdev[dev_id].chip[i].error_cnt,chip_nonce_conunts[i],chip_work_conunts[i],rmdev[dev_id].chip[i].freq+1);
+				chip_nonce_conunts[i] = 0;
+				chip_work_conunts[i] = 0;
 #endif
-			if(rmdev[dev_id].chip[i].error_cnt>=12)
-				{
-				if(rmdev[dev_id].chip[i].freq>rmdev[dev_id].min_frq)	//200Mhz
-					{
-					rmdev[dev_id].chip[i].freq --;
+				if (rmdev[dev_id].chip[i].error_cnt>=12) {
+					if (rmdev[dev_id].chip[i].freq>rmdev[dev_id].min_frq) {	//200Mhz
+						rmdev[dev_id].chip[i].freq --;
 #ifdef  NONCE_TEST
-				applog(LOG_WARNING, "AMU%d Chip[%d]=%d SUB FREQ TO %d0MHz,DEF(%fMHz) ",dev_id,i,rmdev[dev_id].chip[i].error_cnt,rmdev[dev_id].chip[i].freq+1,opt_rock_freq);
+						applog(LOG_WARNING, "AMU%d Chip[%d]=%d SUB FREQ TO %d0MHz,DEF(%fMHz) ",dev_id,i,rmdev[dev_id].chip[i].error_cnt,rmdev[dev_id].chip[i].freq+1,opt_rock_freq);
 #endif
 					}
-				}
-			else if(rmdev[dev_id].chip[i].error_cnt<=1)
-				{
-				if(rmdev[dev_id].chip[i].freq<(rmdev[dev_id].def_frq/10-1))
-					{
-					rmdev[dev_id].chip[i].freq ++;
+				} else if(rmdev[dev_id].chip[i].error_cnt <= 1) {
+					if(rmdev[dev_id].chip[i].freq<(rmdev[dev_id].def_frq/10-1)) {
+						rmdev[dev_id].chip[i].freq ++;
 #ifdef  NONCE_TEST
-				applog(LOG_WARNING, "AMU%d Chip[%d]=%d ADD FREQ TO %d0MHz,DEF(%fMHz) ",dev_id,i,rmdev[dev_id].chip[i].error_cnt,rmdev[dev_id].chip[i].freq+1,opt_rock_freq);
+						applog(LOG_WARNING, "AMU%d Chip[%d]=%d ADD FREQ TO %d0MHz,DEF(%fMHz) ",dev_id,i,rmdev[dev_id].chip[i].error_cnt,rmdev[dev_id].chip[i].freq+1,opt_rock_freq);
 #endif
 					}
 				}
-			rmdev[dev_id].chip[i].error_cnt = 0;
+				rmdev[dev_id].chip[i].error_cnt = 0;
 			}
 #ifdef NONCE_TEST// ROCKMINER_PRINT_DEBUG
-						device_nonce_corr_ok[dev_id] = 0;
-						device_nonce_corr_fail[dev_id] = 0;
-						device_nonce_corr_fail_2[dev_id] = 0;
-						device_nonce_conunts[dev_id] = 0;
+			device_nonce_corr_ok[dev_id] = 0;
+			device_nonce_corr_fail[dev_id] = 0;
+			device_nonce_corr_fail_2[dev_id] = 0;
+			device_nonce_conunts[dev_id] = 0;
 #endif
-
 		}
 
 	correction_times = 0;
-	while(correction_times<NONCE_CORRECTION_TIMES)
-	{
-		if (submit_nonce(thr, work, nonce + correction_value[correction_times]))
-		{
+	while (correction_times < NONCE_CORRECTION_TIMES) {
+		if (submit_nonce(thr, work, nonce + correction_value[correction_times])) {
 			hash_count++;
 			info->failing = false;
 #if ROCKMINER_PRINT_DEBUG
 			applog(LOG_WARNING, "Rockminer nonce :::OK:::\r\n");
 #endif
 			break;
-		}
-		else
-		{
+		} else {
 #if ROCKMINER_PRINT_DEBUG
 			applog(LOG_WARNING, "Rockminer nonce error times = %d\r\n", correction_times);
 #endif
-			if(nonce == 0)
-			{
+			if (nonce == 0)
 				break;
-			}
 		}
 		correction_times++;
 	}
 
-	if(correction_times > 0 )
-	{
-
-	/* FIXME: Where is this i supposed to come from? Comment out instead */
-	//rmdev[dev_id].chip[i].error_cnt ++;
-	    if (correction_times < NONCE_CORRECTION_TIMES)
-	    	{
+	if (correction_times > 0 ) {
+		/* FIXME: Where is this i supposed to come from? Comment out instead */
+		//rmdev[dev_id].chip[i].error_cnt ++;
+		if (correction_times < NONCE_CORRECTION_TIMES) {
 
 #ifdef NONCE_TEST// ROCKMINER_PRINT_DEBUG
 	    		device_nonce_corr_ok[dev_id] ++;
-		//applog(LOG_WARNING, "Rockminer correction the nonce success %s%d[%d]=%d",icarus->drv->name, icarus->dev_id,chip_no,correction_times);
+			//applog(LOG_WARNING, "Rockminer correction the nonce success %s%d[%d]=%d",icarus->drv->name, icarus->dev_id,chip_no,correction_times);
 #endif
-	    	}
-		else
-			{
+	    	} else {
 #ifdef NONCE_TEST// ROCKMINER_PRINT_DEBUG
-		device_nonce_corr_fail[dev_id] ++;
+			device_nonce_corr_fail[dev_id] ++;
 #endif
-		//applog(LOG_WARNING, "Rockminer correction the nonce fail ---------%s%d[%d]=%d",icarus->drv->name, icarus->dev_id,chip_no,correction_times);
-			}
-
+			//applog(LOG_WARNING, "Rockminer correction the nonce fail ---------%s%d[%d]=%d",icarus->drv->name, icarus->dev_id,chip_no,correction_times);
+		}
 	}
 
 	hash_count = (hash_count * info->nonce_mask);