thodg/cgminer

diff --git a/01-cgminer.rules b/01-cgminer.rules
index d2fa52a..feb432e 100644
--- a/01-cgminer.rules
+++ b/01-cgminer.rules
@@ -37,3 +37,6 @@ ATTRS{idVendor}=="198c", ATTRS{idProduct}=="b1f1", SUBSYSTEM=="usb", ACTION=="ad
 
 # NF1
 ATTRS{idVendor}=="04d8", ATTRS{idProduct}=="00de", SUBSYSTEM=="usb", ACTION=="add", MODE="0666", GROUP="plugdev"
+
+# ANT_S1
+ATTRS{idVendor}=="4254", ATTRS{idProduct}=="4153", SUBSYSTEM=="usb", ACTION=="add", MODE="0666", GROUP="plugdev"
diff --git a/ASIC-README b/ASIC-README
index 25de102..058d8a6 100644
--- a/ASIC-README
+++ b/ASIC-README
@@ -12,6 +12,7 @@ Currently supported devices include:
 - Hashfast Babyjet and Sierra
 - Antminer U1 USB
 - Cointerra
+- Antminer S1
 
 No COM ports on windows or TTY devices will be used by cgminer as it
 communicates directly with them via USB so it is normal for them to not exist or
@@ -84,7 +85,7 @@ HFS: Hashfast Sierra
 HFA: Hashfast non standard (eg. a Babyjet with an added board)
 
 
-ANTMINER devices
+ANTMINER U1 devices
 
 Antminer devices need the --enable-icarus option when compiling cgminer.
 
@@ -93,6 +94,15 @@ are also set up as per the USB ASICs below. They need no options to work well
 but will accept all the icarus options.
 
 
+ANTMINER S1 devices
+
+Antminer S1 devices need the --enable-ants1 option when compiling cgminer.
+
+They are custom OpenWRT linux devices
+
+They are recognised with the name ANT
+
+
 BITMINE A1 devices
 
 Bitmine A1 devices need the --enable-bitmine_A1 compile option set.
@@ -192,6 +202,13 @@ ASIC SPECIFIC COMMANDS
 --bitburner-fury-options <arg> Override avalon-options for BitBurner Fury boards baud:miners:asic:timeout:freq
 --bitburner-fury-voltage <arg> Set BitBurner Fury core voltage, in millivolts
 --bitburner-voltage <arg> Set BitBurner (Avalon) core voltage, in millivolts
+--bitmain-auto      Adjust bitmain overclock frequency dynamically for best hashrate
+--bitmain-cutoff    Set bitmain overheat cut off temperature
+--bitmain-fan       Set fanspeed percentage for bitmain, single value or range (default: 20-100)
+--bitmain-freq      Set frequency range for bitmain-auto, single value or range
+--bitmain-hwerror   Set bitmain device detect hardware error
+--bitmain-options   Set bitmain options baud:miners:asic:timeout:freq
+--bitmain-temp      Set bitmain target temperature
 --bxf-temp-target <arg> Set target temperature for BXF devices (default: 82)
 --hfa-hash-clock <arg> Set hashfast clock speed (default: 550)
 --hfa-fail-drop <arg> Set how many MHz to drop clockspeed each failure on an overlocked hashfast device (default: 10)
@@ -203,6 +220,21 @@ ASIC SPECIFIC COMMANDS
 --klondike-options <arg> Set klondike options clock:temptarget
 
 
+ANTMINER S1 DEVICES
+
+--bitmain-auto      Adjust bitmain overclock frequency dynamically for best hashrate
+--bitmain-cutoff    Set bitmain overheat cut off temperature
+--bitmain-fan       Set fanspeed percentage for bitmain, single value or range (default: 20-100)
+--bitmain-freq      Set frequency range for bitmain-auto, single value or range
+--bitmain-hwerror   Set bitmain device detect hardware error
+--bitmain-options   Set bitmain options baud:miners:asic:timeout:freq
+--bitmain-temp      Set bitmain target temperature
+
+The Antminer S1 device comes with it's own operating system and a preinstalled
+version of cgminer as part of the flash firmware. No configuration should be
+necessary.
+
+
 ANTMINER U1 DEVICES
 
 --anu-freq <arg>    Set AntminerU1 frequency in MHz, range 150-500 (default: 200)
diff --git a/Makefile.am b/Makefile.am
index cc81a8f..658bfa2 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -116,6 +116,10 @@ if HAS_MINION
 cgminer_SOURCES += driver-minion.c
 endif
 
+if HAS_ANT_S1
+cgminer_SOURCES += driver-bitmain.c driver-bitmain.h
+endif
+
 if HAS_MODMINER
 cgminer_SOURCES += driver-modminer.c
 bitstreamsdir = $(bindir)/bitstreams
diff --git a/README b/README
index 56b6f3e..3cecbce 100644
--- a/README
+++ b/README
@@ -105,6 +105,8 @@ If building on Ubuntu:
 	sudo apt-get install build-essential autoconf automake libtool libcurl3-dev libudev-dev
 
 CGMiner specific configuration options:
+  --enable-ants1          Compile support for Antminer S1 Bitmain (default
+                          disabled)
   --enable-avalon         Compile support for Avalon (default disabled)
   --enable-bab            Compile support for BlackArrow Bitfury (default
                           disabled)
@@ -119,8 +121,6 @@ CGMiner specific configuration options:
   --enable-hashfast       Compile support for Hashfast (default disabled)
   --enable-icarus         Compile support for Icarus (default disabled)
   --enable-knc            Compile support for KnC miners (default disabled)
-  --enable-bab            Compile support for BlackArrow Bitfury (default disabled)
-  --enable-minion         Compile support for BlackArrow Minion ASIC (default disabled)
   --enable-klondike       Compile support for Klondike (default disabled)
   --enable-knc            Compile support for KnC miners (default disabled)
   --enable-minion         Compile support for Minion BlackArrow ASIC (default
@@ -180,6 +180,13 @@ Options for both config file and command line:
 --bitburner-fury-voltage <arg> Set BitBurner Fury core voltage, in millivolts
 --bitburner-fury-options <arg> Override avalon-options for BitBurner Fury boards baud:miners:asic:timeout:freq
 --bitburner-voltage <arg> Set BitBurner (Avalon) core voltage, in millivolts
+--bitmain-auto      Adjust bitmain overclock frequency dynamically for best hashrate
+--bitmain-cutoff    Set bitmain overheat cut off temperature
+--bitmain-fan       Set fanspeed percentage for bitmain, single value or range (default: 20-100)
+--bitmain-freq      Set frequency range for bitmain-auto, single value or range
+--bitmain-hwerror   Set bitmain device detect hardware error
+--bitmain-options   Set bitmain options baud:miners:asic:timeout:freq
+--bitmain-temp      Set bitmain target temperature
 --bxf-temp-target <arg> Set target temperature for BXF devices (default: 82)
 --compact           Use compact display without per device statistics
 --debug|-D          Enable debug output
diff --git a/api.c b/api.c
index e3dc72d..3ea0e3e 100644
--- a/api.c
+++ b/api.c
@@ -29,7 +29,8 @@
 #if defined(USE_BFLSC) || defined(USE_AVALON) || defined(USE_AVALON2) || \
 	defined(USE_HASHFAST) || defined(USE_BITFURY) || defined(USE_KLONDIKE) || \
 	defined(USE_KNC) || defined(USE_BAB) || defined(USE_DRILLBIT) || \
-	defined(USE_MINION) || defined(USE_COINTERRA) || defined(USE_BITMINE_A1)
+	defined(USE_MINION) || defined(USE_COINTERRA) || defined(USE_BITMINE_A1) || \
+	defined(USE_ANT_S1)
 #define HAVE_AN_ASIC 1
 #endif
 
@@ -153,6 +154,9 @@ static const char *FALSESTR = "false";
 static const char *SHA256STR = "sha256";
 
 static const char *DEVICECODE = ""
+#ifdef USE_ANT_S1
+			"ANT "
+#endif
 #ifdef USE_AVALON
 			"AVA "
 #endif
diff --git a/cgminer.c b/cgminer.c
index b9b8591..c2d56e7 100644
--- a/cgminer.c
+++ b/cgminer.c
@@ -88,6 +88,10 @@ char *curly = ":D";
 #include "driver-hashfast.h"
 #endif
 
+#ifdef USE_ANT_S1
+#include "driver-bitmain.h"
+#endif
+
 #if defined(USE_BITFORCE) || defined(USE_ICARUS) || defined(USE_AVALON) || defined(USE_AVALON2) || defined(USE_MODMINER)
 #	define USE_FPGA
 #endif
@@ -209,6 +213,9 @@ char *opt_bab_options = NULL;
 #ifdef USE_BITMINE_A1
 char *opt_bitmine_a1_options = NULL;
 #endif
+#ifdef USE_ANT_S1
+char *opt_bitmain_options = NULL;
+#endif
 #ifdef USE_USBUTILS
 char *opt_usb_select = NULL;
 int opt_usbdump = -1;
@@ -360,7 +367,7 @@ struct sigaction termhandler, inthandler;
 
 struct thread_q *getq;
 
-static int total_work;
+static uint32_t total_work;
 struct work *staged_work = NULL;
 
 struct schedtime {
@@ -1252,6 +1259,29 @@ static struct opt_table opt_config_table[] = {
 		     set_bitburner_fury_options, NULL, NULL,
 		     "Override avalon-options for BitBurner Fury boards baud:miners:asic:timeout:freq"),
 #endif
+#ifdef USE_ANT_S1
+	OPT_WITHOUT_ARG("--bitmain-auto",
+			opt_set_bool, &opt_bitmain_auto,
+			"Adjust bitmain overclock frequency dynamically for best hashrate"),
+	OPT_WITH_ARG("--bitmain-cutoff",
+		     set_int_0_to_100, opt_show_intval, &opt_bitmain_overheat,
+		     "Set bitmain overheat cut off temperature"),
+	OPT_WITH_ARG("--bitmain-fan",
+		     set_bitmain_fan, NULL, NULL,
+		     "Set fanspeed percentage for bitmain, single value or range (default: 20-100)"),
+	OPT_WITH_ARG("--bitmain-freq",
+		     set_bitmain_freq, NULL, NULL,
+		     "Set frequency range for bitmain-auto, single value or range"),
+	OPT_WITHOUT_ARG("--bitmain-hwerror",
+			opt_set_bool, &opt_bitmain_hwerror,
+			"Set bitmain device detect hardware error"),
+	OPT_WITH_ARG("--bitmain-options",
+		     opt_set_charp, NULL, &opt_bitmain_options,
+		     "Set bitmain options baud:miners:asic:timeout:freq"),
+	OPT_WITH_ARG("--bitmain-temp",
+		     set_int_0_to_100, opt_show_intval, &opt_bitmain_temp,
+		     "Set bitmain target temperature"),
+#endif
 #ifdef USE_BITMINE_A1
 	OPT_WITH_ARG("--bitmine-a1-options",
 		     set_bitmine_a1_options, NULL, NULL,
@@ -1644,6 +1674,9 @@ extern const char *opt_argv0;
 static char *opt_verusage_and_exit(const char *extra)
 {
 	printf("%s\nBuilt with "
+#ifdef USE_ANT_S1
+		"ant.S1 "
+#endif
 #ifdef USE_AVALON
 		"avalon "
 #endif
@@ -3829,7 +3862,7 @@ static char *offset_ntime(const char *ntime, int noffset)
  * prevent a copied work struct from freeing ram belonging to another struct */
 static void _copy_work(struct work *work, const struct work *base_work, int noffset)
 {
-	int id = work->id;
+	uint32_t id = work->id;
 
 	clean_work(work);
 	memcpy(work, base_work, sizeof(struct work));
@@ -7024,6 +7057,35 @@ struct work *clone_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate
 	return ret;
 }
 
+/* This function is for finding an already queued work item in the
+ * given que hashtable. Code using this function must be able
+ * to handle NULL as a return which implies there is no matching work.
+ * The calling function must lock access to the que if it is required. */
+struct work *__find_work_byid(struct work *que, uint32_t id)
+{
+	struct work *work, *tmp, *ret = NULL;
+
+	HASH_ITER(hh, que, work, tmp) {
+		if (work->id == id) {
+			ret = work;
+			break;
+		}
+	}
+
+	return ret;
+}
+
+struct work *find_queued_work_byid(struct cgpu_info *cgpu, uint32_t id)
+{
+	struct work *ret;
+
+	rd_lock(&cgpu->qlock);
+	ret = __find_work_byid(cgpu->queued_work, id);
+	rd_unlock(&cgpu->qlock);
+
+	return ret;
+}
+
 void __work_completed(struct cgpu_info *cgpu, struct work *work)
 {
 	cgpu->queued_count--;
diff --git a/configure.ac b/configure.ac
index 260bf41..77adfab 100644
--- a/configure.ac
+++ b/configure.ac
@@ -126,6 +126,17 @@ if test "x$has_winpthread" != xtrue; then
         PTHREAD_LIBS=-lpthread
 fi
 
+ants1="no"
+
+AC_ARG_ENABLE([ants1],
+	[AC_HELP_STRING([--enable-ants1],[Compile support for Antminer S1 Bitmain (default disabled)])],
+	[ants1=$enableval]
+	)
+if test "x$ants1" = xyes; then
+	AC_DEFINE([USE_ANT_S1], [1], [Defined to 1 if Antminer S1 Bitmain support is wanted])
+fi
+AM_CONDITIONAL([HAS_ANT_S1], [test x$ants1 = xyes])
+
 avalon="no"
 
 AC_ARG_ENABLE([avalon],
@@ -317,7 +328,7 @@ else
 	])
 fi
 
-if test x$avalon$bitforce$bitfury$modminer$bflsc$icarus$hashfast$klondike$drillbit$cointerra != xnononononononononono; then
+if test x$avalon$bitforce$bitfury$modminer$bflsc$icarus$hashfast$klondike$drillbit$cointerra$ants1 != xnonononononononononono; then
 	want_usbutils=true
 else
 	want_usbutils=false
@@ -497,6 +508,12 @@ echo "  curses.TUI...........: $cursesmsg"
 
 
 echo
+if test "x$ants1" = xyes; then
+	echo "  Antminer.S1.Bitmain..: Enabled"
+else
+	echo "  Antminer.S1.Bitmain..: Disabled"
+fi
+
 if test "x$avalon" = xyes; then
 	echo "  Avalon.ASICs.........: Enabled"
 else
@@ -587,7 +604,7 @@ else
 	echo "  ModMiner.FPGAs.......: Disabled"
 fi
 
-if test "x$avalon$avalon2$bab$bflsc$bitforce$bitfury$hashfast$icarus$klondike$knc$modminer$drillbit$minion$cointerra$bitmine_A1" = xnonononononononononononononono; then
+if test "x$avalon$avalon2$bab$bflsc$bitforce$bitfury$hashfast$icarus$klondike$knc$modminer$drillbit$minion$cointerra$bitmine_A1$ants1" = xnononononononononononononononono; then
 	AC_MSG_ERROR([No mining configured in])
 fi
 
diff --git a/driver-bitmain.c b/driver-bitmain.c
index 184d5f1..3a5d3ae 100644
--- a/driver-bitmain.c
+++ b/driver-bitmain.c
@@ -1,5 +1,6 @@
 /*
  * Copyright 2012-2013 Lingchao Xu <lingchao.xu@bitmaintech.com>
+ * Copyright 2014 Andrew Smith
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -8,7 +9,16 @@
  */
 
 #include "config.h"
+#include "compat.h"
+#include "miner.h"
 
+#ifndef LINUX
+static void ants1_detect(__maybe_unused bool hotplug)
+{
+}
+#else
+
+/*
 #include <limits.h>
 #include <pthread.h>
 #include <stdio.h>
@@ -16,30 +26,22 @@
 #include <sys/types.h>
 #include <dirent.h>
 #include <unistd.h>
-#ifndef WIN32
-  #include <sys/select.h>
-  #include <termios.h>
-  #include <sys/stat.h>
-  #include <fcntl.h>
-  #ifndef O_CLOEXEC
-    #define O_CLOEXEC 0
-  #endif
-#else
-  #include "compat.h"
-  #include <windows.h>
-  #include <io.h>
+#include <sys/select.h>
+#include <termios.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#ifndef O_CLOEXEC
+#define O_CLOEXEC 0
 #endif
+*/
 
 #include "elist.h"
-#include "miner.h"
 #include "usbutils.h"
 #include "driver-bitmain.h"
 #include "hexdump.c"
 #include "util.h"
 
-char opt_bitmain_dev[256] = {0};
 bool opt_bitmain_hwerror = false;
-bool opt_bitmain_dev_usb = true;
 int opt_bitmain_temp = BITMAIN_TEMP_TARGET;
 int opt_bitmain_overheat = BITMAIN_TEMP_OVERHEAT;
 int opt_bitmain_fan_min = BITMAIN_DEFAULT_FAN_MIN_PWM;
@@ -50,10 +52,48 @@ bool opt_bitmain_auto;
 
 static int option_offset = -1;
 
+static unsigned char bit_swap_table[256] =
+{
+  0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+  0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+  0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+  0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+  0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+  0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+  0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+  0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+  0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+  0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+  0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+  0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+  0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+  0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+  0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+  0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+  0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+  0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+  0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+  0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+  0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+  0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+  0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+  0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+  0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+  0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+  0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+  0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+  0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+  0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+  0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+  0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
+};
+
+#define bitswap(x) (bit_swap_table[x])
+
 // --------------------------------------------------------------
 //      CRC16 check table
 // --------------------------------------------------------------
-const uint8_t chCRCHTalbe[] =                                 // CRC high byte table
+const uint8_t chCRCHTalbe[] = // CRC high byte table
 {
  0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
  0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
@@ -79,7 +119,7 @@ const uint8_t chCRCHTalbe[] =                                 // CRC high byte t
  0x00, 0xC1, 0x81, 0x40
 };
 
-const uint8_t chCRCLTalbe[] =                                 // CRC low byte table
+const uint8_t chCRCLTalbe[] = // CRC low byte table
 {
  0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
  0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
@@ -119,42 +159,12 @@ static uint16_t CRC16(const uint8_t* p_data, uint16_t w_len)
 	return ((chCRCHi << 8) | chCRCLo);
 }
 
-static uint32_t num2bit(int num) {
-	switch(num) {
-	case 0:  return 0x80000000;
-	case 1:  return 0x40000000;
-	case 2:  return 0x20000000;
-	case 3:  return 0x10000000;
-	case 4:  return 0x08000000;
-	case 5:  return 0x04000000;
-	case 6:  return 0x02000000;
-	case 7:  return 0x01000000;
-	case 8:  return 0x00800000;
-	case 9:  return 0x00400000;
-	case 10: return 0x00200000;
-	case 11: return 0x00100000;
-	case 12: return 0x00080000;
-	case 13: return 0x00040000;
-	case 14: return 0x00020000;
-	case 15: return 0x00010000;
-	case 16: return 0x00008000;
-	case 17: return 0x00004000;
-	case 18: return 0x00002000;
-	case 19: return 0x00001000;
-	case 20: return 0x00000800;
-	case 21: return 0x00000400;
-	case 22: return 0x00000200;
-	case 23: return 0x00000100;
-	case 24: return 0x00000080;
-	case 25: return 0x00000040;
-	case 26: return 0x00000020;
-	case 27: return 0x00000010;
-	case 28: return 0x00000008;
-	case 29: return 0x00000004;
-	case 30: return 0x00000002;
-	case 31: return 0x00000001;
-	default: return 0x00000000;
-	}
+static uint32_t num2bit(int num)
+{
+	if (num < 0 || num > 31)
+		return 0;
+	else
+		return (((uint32_t)1) << (31 - num));
 }
 
 static bool get_options(int this_option_offset, int *baud, int *chain_num,
@@ -197,21 +207,21 @@ static bool get_options(int this_option_offset, int *baud, int *chain_num,
 
 	tmp = atoi(buf);
 	switch (tmp) {
-	case 115200:
-		*baud = 115200;
-		break;
-	case 57600:
-		*baud = 57600;
-		break;
-	case 38400:
-		*baud = 38400;
-		break;
-	case 19200:
-		*baud = 19200;
-		break;
-	default:
-		quit(1, "Invalid bitmain-options for baud (%s) "
-			"must be 115200, 57600, 38400 or 19200", buf);
+		case 115200:
+			*baud = 115200;
+			break;
+		case 57600:
+			*baud = 57600;
+			break;
+		case 38400:
+			*baud = 38400;
+			break;
+		case 19200:
+			*baud = 19200;
+				break;
+		default:
+			quit(1, "Invalid bitmain-options for baud (%s) "
+				"must be 115200, 57600, 38400 or 19200", buf);
 	}
 
 	if (colon && *colon) {
@@ -221,9 +231,9 @@ static bool get_options(int this_option_offset, int *baud, int *chain_num,
 
 		if (*colon) {
 			tmp = atoi(colon);
-			if (tmp > 0) {
+			if (tmp > 0)
 				*chain_num = tmp;
-			} else {
+			else {
 				quit(1, "Invalid bitmain-options for "
 					"chain_num (%s) must be 1 ~ %d",
 					colon, BITMAIN_DEFAULT_CHAIN_NUM);
@@ -259,25 +269,32 @@ static bool get_options(int this_option_offset, int *baud, int *chain_num,
 				}
 				if (colon4 && *colon4) {
 					colon5 = strchr(colon4, ':');
-					if(colon5)
+					if (colon5)
 						*(colon5++) = '\0';
 
 					tmp = atoi(colon4);
-					if (tmp < BITMAIN_MIN_FREQUENCY || tmp > BITMAIN_MAX_FREQUENCY) {
-						quit(1, "Invalid bitmain-options for frequency, must be %d <= frequency <= %d",
-						     BITMAIN_MIN_FREQUENCY, BITMAIN_MAX_FREQUENCY);
-					} else {
+					if (tmp < BITMAIN_MIN_FREQUENCY ||
+					    tmp > BITMAIN_MAX_FREQUENCY) {
+						quit(1, "Invalid bitmain-options for frequency,"
+							" must be %d <= frequency <= %d",
+							BITMAIN_MIN_FREQUENCY,
+							BITMAIN_MAX_FREQUENCY);
+					} else
 						*frequency = tmp;
-					}
+
 					if (colon5 && *colon5) {
-						if(strlen(colon5) > 8 || strlen(colon5)%2 != 0 || strlen(colon5)/2 == 0) {
-							quit(1, "Invalid bitmain-options for reg data, must be hex now: %s",
-									colon5);
+						if (strlen(colon5) > 8 ||
+						    strlen(colon5)%2 != 0 ||
+						    strlen(colon5)/2 == 0) {
+							quit(1, "Invalid bitmain-options for"
+								" reg data, must be hex now: %s",
+								colon5);
 						}
 						memset(reg_data, 0, 4);
-						if(!hex2bin(reg_data, colon5, strlen(colon5)/2)) {
-							quit(1, "Invalid bitmain-options for reg data, hex2bin error now: %s",
-									colon5);
+						if (!hex2bin(reg_data, colon5, strlen(colon5)/2)) {
+							quit(1, "Invalid bitmain-options for reg"
+								" data, hex2bin error now: %s",
+								colon5);
 						}
 					}
 				}
@@ -296,15 +313,16 @@ static int bitmain_set_txconfig(struct bitmain_txconfig_token *bm,
 {
 	uint16_t crc = 0;
 	int datalen = 0;
-	uint8_t * sendbuf = (uint8_t *)bm;
+	uint8_t *sendbuf = (uint8_t *)bm;
 	if (unlikely(!bm)) {
 		applog(LOG_WARNING, "bitmain_set_txconfig bitmain_txconfig_token is null");
 		return -1;
 	}
 
 	if (unlikely(timeout_data <= 0 || asic_num <= 0 || chain_num <= 0)) {
-		applog(LOG_WARNING, "bitmain_set_txconfig parameter invalid timeout_data(%d) asic_num(%d) chain_num(%d)",
-				timeout_data, asic_num, chain_num);
+		applog(LOG_WARNING, "bitmain_set_txconfig parameter invalid"
+				    " timeout_data(%d) asic_num(%d) chain_num(%d)",
+				    timeout_data, asic_num, chain_num);
 		return -1;
 	}
 
@@ -322,7 +340,7 @@ static int bitmain_set_txconfig(struct bitmain_txconfig_token *bm,
 	bm->chip_config_eft = chip_config_eft;
 	bm->hw_error_eft = hw_error_eft;
 
-	sendbuf[2] = htole8(sendbuf[2]);
+	sendbuf[2] = bitswap(sendbuf[2]);
 
 	bm->chain_num = chain_num;
 	bm->asic_num = asic_num;
@@ -340,37 +358,36 @@ static int bitmain_set_txconfig(struct bitmain_txconfig_token *bm,
 	crc = CRC16((uint8_t *)bm, datalen-2);
 	bm->crc = htole16(crc);
 
-	applog(LOG_ERR, "BTM TxConfigToken:reset(%d) faneft(%d) touteft(%d) freqeft(%d) volteft(%d) chainceft(%d) chipceft(%d) hweft(%d) mnum(%d) anum(%d) fanpwmdata(%d) toutdata(%d) freq(%d) volt(%d) chainctime(%d) regdata(%02x%02x%02x%02x) chipaddr(%02x) regaddr(%02x) crc(%04x)",
-					reset, fan_eft, timeout_eft, frequency_eft, voltage_eft,
-					chain_check_time_eft, chip_config_eft, hw_error_eft, chain_num, asic_num,
-					fan_pwm_data, timeout_data, frequency, voltage,
-					chain_check_time, reg_data[0], reg_data[1], reg_data[2], reg_data[3], chip_address, reg_address, crc);
+	applog(LOG_ERR, "BTM TxConfigToken:reset(%d) faneft(%d) touteft(%d) freqeft(%d)"
+			" volteft(%d) chainceft(%d) chipceft(%d) hweft(%d) mnum(%d)"
+			" anum(%d) fanpwmdata(%d) toutdata(%d) freq(%d) volt(%d)"
+			" chainctime(%d) regdata(%02x%02x%02x%02x) chipaddr(%02x)"
+			" regaddr(%02x) crc(%04x)",
+			reset, fan_eft, timeout_eft, frequency_eft, voltage_eft,
+			chain_check_time_eft, chip_config_eft, hw_error_eft,
+			chain_num, asic_num, fan_pwm_data, timeout_data, frequency,
+			voltage, chain_check_time, reg_data[0], reg_data[1],
+			reg_data[2], reg_data[3], chip_address, reg_address, crc);
 
 	return datalen;
 }
 
-#ifdef WIN32
-#define BITMAIN_TEST
-#endif
-
-#ifdef BITMAIN_TEST
-const char * btm_work_test_data = "00000002ddc1ce5579dbec17f17fbb8f31ae218a814b2a0c1900f0d90000000100000000b58aa6ca86546b07a5a46698f736c7ca9c0eedc756d8f28ac33c20cc24d792675276f879190afc85b6888022000000800000000000000000000000000000000000000000000000000000000000000000";
-const char * btm_work_test_midstate = "2d8738e7f5bcf76dcb8316fec772e20e240cd58c88d47f2d3f5a6a9547ed0a35";
-#endif
-
-static int bitmain_set_txtask(uint8_t * sendbuf,
-			    unsigned int * last_work_block, struct work **works, int work_array_size, int work_array, int sendworkcount, int * sendcount)
+static int bitmain_set_txtask(uint8_t *sendbuf, unsigned int *last_work_block,
+			      struct work **works, int work_array_size, int work_array,
+			      int sendworkcount, int *sendcount)
 {
 	uint16_t crc = 0;
 	uint32_t work_id = 0;
 	int datalen = 0;
 	int i = 0;
 	int index = work_array;
-	uint8_t new_block= 0;
-	char * ob_hex = NULL;
+	uint8_t new_block = 0;
+	//char *ob_hex = NULL;
 	struct bitmain_txtask_token *bm = (struct bitmain_txtask_token *)sendbuf;
-	*sendcount = 0;
 	int cursendcount = 0;
+
+	*sendcount = 0;
+
 	if (unlikely(!bm)) {
 		applog(LOG_WARNING, "bitmain_set_txtask bitmain_txtask_token is null");
 		return -1;
@@ -385,27 +402,28 @@ static int bitmain_set_txtask(uint8_t * sendbuf,
 
 	datalen = 10;
 	applog(LOG_DEBUG, "BTM send work count %d -----", sendworkcount);
-	for(i = 0; i < sendworkcount; i++) {
-		if(index > work_array_size) {
+	for (i = 0; i < sendworkcount; i++) {
+		if (index > work_array_size)
 			index = 0;
-		}
-		if(works[index]) {
-			if(works[index]->work_block > *last_work_block) {
-				applog(LOG_ERR, "BTM send task new block %d old(%d)", works[index]->work_block, *last_work_block);
+
+		if (works[index]) {
+			if (works[index]->work_block > *last_work_block) {
+				applog(LOG_ERR, "BTM send task new block %d old(%d)",
+						works[index]->work_block, *last_work_block);
 				new_block = 1;
 				*last_work_block = works[index]->work_block;
 			}
 #ifdef BITMAIN_TEST
-			if(!hex2bin(works[index]->data, btm_work_test_data, 128)) {
+			if (!hex2bin(works[index]->data, btm_work_test_data, 128))
 				applog(LOG_DEBUG, "BTM send task set test data error");
-			}
-			if(!hex2bin(works[index]->midstate, btm_work_test_midstate, 32)) {
+
+			if (!hex2bin(works[index]->midstate, btm_work_test_midstate, 32))
 				applog(LOG_DEBUG, "BTM send task set test midstate error");
-			}
 #endif
 			work_id = works[index]->id;
 			bm->works[cursendcount].work_id = htole32(work_id);
-			applog(LOG_DEBUG, "BTM send task work id:%d %d", bm->works[cursendcount].work_id, work_id);
+			applog(LOG_DEBUG, "BTM send task work id:%"PRIu32" %"PRIu32,
+					  bm->works[cursendcount].work_id, work_id);
 			memcpy(bm->works[cursendcount].midstate, works[index]->midstate, 32);
 			memcpy(bm->works[cursendcount].data2, works[index]->data + 64, 12);
 
@@ -417,7 +435,7 @@ static int bitmain_set_txtask(uint8_t * sendbuf,
 		}
 		index++;
 	}
-	if(cursendcount <= 0) {
+	if (cursendcount <= 0) {
 		applog(LOG_ERR, "BTM send work count %d", cursendcount);
 		return 0;
 	}
@@ -430,10 +448,12 @@ static int bitmain_set_txtask(uint8_t * sendbuf,
 	//memcpy(sendbuf+1, &len, 2);
 	bm->new_block = new_block;
 
-	sendbuf[4] = htole8(sendbuf[4]);
+	sendbuf[4] = bitswap(sendbuf[4]);
 
 	applog(LOG_DEBUG, "BitMain TxTask Token: %d %d %02x%02x%02x%02x%02x%02x",
-				datalen, bm->length, sendbuf[0],sendbuf[1],sendbuf[2],sendbuf[3],sendbuf[4],sendbuf[5]);
+			  datalen, bm->length,
+			  sendbuf[0], sendbuf[1], sendbuf[2],
+			  sendbuf[3], sendbuf[4], sendbuf[5]);
 
 	*sendcount = cursendcount;
 
@@ -442,9 +462,11 @@ static int bitmain_set_txtask(uint8_t * sendbuf,
 	memcpy(sendbuf+datalen-2, &crc, 2);
 
 	applog(LOG_DEBUG, "BitMain TxTask Token: new_block(%d) work_num(%d) crc(%04x)",
-						new_block, cursendcount, crc);
+			  new_block, cursendcount, crc);
 	applog(LOG_DEBUG, "BitMain TxTask Token: %d %d %02x%02x%02x%02x%02x%02x",
-			datalen, bm->length, sendbuf[0],sendbuf[1],sendbuf[2],sendbuf[3],sendbuf[4],sendbuf[5]);
+			  datalen, bm->length,
+			  sendbuf[0], sendbuf[1], sendbuf[2],
+			  sendbuf[3], sendbuf[4], sendbuf[5]);
 
 	return datalen;
 }
@@ -454,7 +476,7 @@ static int bitmain_set_rxstatus(struct bitmain_rxstatus_token *bm,
 {
 	uint16_t crc = 0;
 	int datalen = 0;
-	uint8_t * sendbuf = (uint8_t *)bm;
+	uint8_t *sendbuf = (uint8_t *)bm;
 
 	if (unlikely(!bm)) {
 		applog(LOG_WARNING, "bitmain_set_rxstatus bitmain_rxstatus_token is null");
@@ -470,7 +492,7 @@ static int bitmain_set_rxstatus(struct bitmain_rxstatus_token *bm,
 	bm->chip_status_eft = chip_status_eft;
 	bm->detect_get = detect_get;
 
-	sendbuf[2] = htole8(sendbuf[2]);
+	sendbuf[2] = bitswap(sendbuf[2]);
 
 	bm->chip_address = chip_address;
 	bm->reg_address = reg_address;
@@ -478,8 +500,9 @@ static int bitmain_set_rxstatus(struct bitmain_rxstatus_token *bm,
 	crc = CRC16((uint8_t *)bm, datalen-2);
 	bm->crc = htole16(crc);
 
-	applog(LOG_DEBUG, "BitMain RxStatus Token: chip_status_eft(%d) detect_get(%d) chip_address(%02x) reg_address(%02x) crc(%04x)",
-				chip_status_eft, detect_get, chip_address, reg_address, crc);
+	applog(LOG_DEBUG, "BitMain RxStatus Token: chip_status_eft(%d) detect_get(%d)"
+			  " chip_address(%02x) reg_address(%02x) crc(%04x)",
+			  chip_status_eft, detect_get, chip_address, reg_address, crc);
 
 	return datalen;
 }
@@ -493,7 +516,9 @@ static int bitmain_parse_rxstatus(const uint8_t * data, int datalen, struct bitm
 		return -1;
 	}
 	if (unlikely(!data || datalen <= 0)) {
-		applog(LOG_WARNING, "bitmain_parse_rxstatus parameter invalid data is null or datalen(%d) error", datalen);
+		applog(LOG_WARNING, "bitmain_parse_rxstatus parameter invalid data is null"
+				    " or datalen(%d) error",
+				    datalen);
 		return -1;
 	}
 	memcpy(bm, data, sizeof(struct bitmain_rxstatus_data));
@@ -508,47 +533,53 @@ static int bitmain_parse_rxstatus(const uint8_t * data, int datalen, struct bitm
 	crc = CRC16(data, datalen-2);
 	memcpy(&(bm->crc), data+datalen-2, 2);
 	bm->crc = htole16(bm->crc);
-	if(crc != bm->crc) {
-		applog(LOG_ERR, "bitmain_parse_rxstatus check crc(%d) != bm crc(%d) datalen(%d)", crc, bm->crc, datalen);
+	if (crc != bm->crc) {
+		applog(LOG_ERR, "bitmain_parse_rxstatus check crc(%d)"
+				" != bm crc(%d) datalen(%d)",
+				crc, bm->crc, datalen);
 		return -1;
 	}
 	bm->fifo_space = htole32(bm->fifo_space);
 	bm->nonce_error = htole32(bm->nonce_error);
-	if(bm->chain_num*5 + bm->temp_num + bm->fan_num + 22 != datalen) {
-		applog(LOG_ERR, "bitmain_parse_rxstatus chain_num(%d) temp_num(%d) fan_num(%d) not match datalen(%d)",
+	if (bm->chain_num*5 + bm->temp_num + bm->fan_num + 22 != datalen) {
+		applog(LOG_ERR, "bitmain_parse_rxstatus chain_num(%d) temp_num(%d)"
+				" fan_num(%d) not match datalen(%d)",
 				bm->chain_num, bm->temp_num, bm->fan_num, datalen);
 		return -1;
 	}
-	if(bm->chain_num > BITMAIN_MAX_CHAIN_NUM) {
+	if (bm->chain_num > BITMAIN_MAX_CHAIN_NUM) {
 		applog(LOG_ERR, "bitmain_parse_rxstatus chain_num=%d error", bm->chain_num);
 		return -1;
 	}
-	if(bm->chain_num > 0) {
+	if (bm->chain_num > 0) {
 		memcpy(bm->chain_asic_status, data+20, bm->chain_num*4);
 		memcpy(bm->chain_asic_num, data+20+bm->chain_num*4, bm->chain_num);
 	}
-	for(i = 0; i < bm->chain_num; i++) {
+	for (i = 0; i < bm->chain_num; i++) {
 		//bm->chain_asic_status[i] = swab32(bm->chain_asic_status[i]);
 		bm->chain_asic_status[i] = htole32(bm->chain_asic_status[i]);
 	}
-	if(bm->temp_num > 0) {
+	if (bm->temp_num > 0) {
 		memcpy(bm->temp, data+20+bm->chain_num*5, bm->temp_num);
 	}
-	if(bm->fan_num > 0) {
+	if (bm->fan_num > 0) {
 		memcpy(bm->fan, data+20+bm->chain_num*5+bm->temp_num, bm->fan_num);
 	}
-	applog(LOG_DEBUG, "BitMain RxStatusData: chipvalueeft(%d) version(%d) fifospace(%d) regvalue(%d) chainnum(%d) tempnum(%d) fannum(%d) crc(%04x)",
-			bm->chip_value_eft, bm->version, bm->fifo_space, bm->reg_value, bm->chain_num, bm->temp_num, bm->fan_num, bm->crc);
+	applog(LOG_DEBUG, "BitMain RxStatusData: chipvalueeft(%d) version(%d) fifospace(%d)"
+			  " regvalue(%d) chainnum(%d) tempnum(%d) fannum(%d) crc(%04x)",
+			  bm->chip_value_eft, bm->version, bm->fifo_space, bm->reg_value,
+			  bm->chain_num, bm->temp_num, bm->fan_num, bm->crc);
 	applog(LOG_DEBUG, "BitMain RxStatus Data chain info:");
-	for(i = 0; i < bm->chain_num; i++) {
-		applog(LOG_DEBUG, "BitMain RxStatus Data chain(%d) asic num=%d asic_status=%08x", i+1, bm->chain_asic_num[i], bm->chain_asic_status[i]);
+	for (i = 0; i < bm->chain_num; i++) {
+		applog(LOG_DEBUG, "BitMain RxStatus Data chain(%d) asic num=%d asic_status=%08x",
+				  i+1, bm->chain_asic_num[i], bm->chain_asic_status[i]);
 	}
 	applog(LOG_DEBUG, "BitMain RxStatus Data temp info:");
-	for(i = 0; i < bm->temp_num; i++) {
+	for (i = 0; i < bm->temp_num; i++) {
 		applog(LOG_DEBUG, "BitMain RxStatus Data temp(%d) temp=%d", i+1, bm->temp[i]);
 	}
 	applog(LOG_DEBUG, "BitMain RxStatus Data fan info:");
-	for(i = 0; i < bm->fan_num; i++) {
+	for (i = 0; i < bm->fan_num; i++) {
 		applog(LOG_DEBUG, "BitMain RxStatus Data fan(%d) fan=%d", i+1, bm->fan[i]);
 	}
 	return 0;
@@ -580,18 +611,22 @@ static int bitmain_parse_rxnonce(const uint8_t * data, int datalen, struct bitma
 	crc = CRC16(data, datalen-2);
 	memcpy(&(bm->crc), data+datalen-2, 2);
 	bm->crc = htole16(bm->crc);
-	if(crc != bm->crc) {
-		applog(LOG_ERR, "bitmain_parse_rxnonce check crc(%d) != bm crc(%d) datalen(%d)", crc, bm->crc, datalen);
+	if (crc != bm->crc) {
+		applog(LOG_ERR, "bitmain_parse_rxnonce check crc(%d)"
+				" != bm crc(%d) datalen(%d)",
+				crc, bm->crc, datalen);
 		return -1;
 	}
 	curnoncenum = (datalen-4)/8;
-	applog(LOG_DEBUG, "BitMain RxNonce Data: nonce_num(%d-%d) fifo_space(%d)", curnoncenum, bm->nonce_num, bm->fifo_space);
-	for(i = 0; i < curnoncenum; i++) {
+	applog(LOG_DEBUG, "BitMain RxNonce Data: nonce_num(%d-%d) fifo_space(%d)",
+			  curnoncenum, bm->nonce_num, bm->fifo_space);
+	for (i = 0; i < curnoncenum; i++) {
 		bm->nonces[i].work_id = htole32(bm->nonces[i].work_id);
 		bm->nonces[i].nonce = htole32(bm->nonces[i].nonce);
 
-		applog(LOG_DEBUG, "BitMain RxNonce Data %d: work_id(%d) nonce(%08x)(%d)",
-				i, bm->nonces[i].work_id, bm->nonces[i].nonce, bm->nonces[i].nonce);
+		applog(LOG_DEBUG, "BitMain RxNonce Data %d: work_id(%"PRIu32") nonce(%08x)(%d)",
+				  i, bm->nonces[i].work_id,
+				  bm->nonces[i].nonce, bm->nonces[i].nonce);
 	}
 	*nonce_num = curnoncenum;
 	return 0;
@@ -600,105 +635,68 @@ static int bitmain_parse_rxnonce(const uint8_t * data, int datalen, struct bitma
 static int bitmain_read(struct cgpu_info *bitmain, unsigned char *buf,
 		       size_t bufsize, int timeout, int ep)
 {
-	int err = 0, readlen = 0;
-	size_t total = 0;
+	int readlen = 0, err = 0;
 
-	if(bitmain == NULL || buf == NULL || bufsize <= 0) {
-		applog(LOG_WARNING, "bitmain_read parameter error bufsize(%d)", bufsize);
+	if (bitmain == NULL || buf == NULL || bufsize <= 0) {
+		applog(LOG_WARNING, "bitmain_read parameter error bufsize(%d)",
+				    (int)bufsize);
 		return -1;
 	}
-	if(opt_bitmain_dev_usb) {
-#ifdef WIN32
-		char readbuf[BITMAIN_READBUF_SIZE];
-		int ofs = 2, cp = 0;
-
-		err = usb_read_once_timeout(bitmain, readbuf, bufsize, &readlen, timeout, ep);
-		applog(LOG_DEBUG, "%s%i: Get bitmain read got readlen %d err %d",
-			bitmain->drv->name, bitmain->device_id, readlen, err);
-
-		if (readlen < 2)
-			goto out;
-
-		while (readlen > 2) {
-			cp = readlen - 2;
-			if (cp > 62)
-				cp = 62;
-			memcpy(&buf[total], &readbuf[ofs], cp);
-			total += cp;
-			readlen -= cp + 2;
-			ofs += 64;
-		}
-#else
-		err = usb_read_once_timeout(bitmain, buf, bufsize, &readlen, timeout, ep);
-		applog(LOG_DEBUG, "%s%i: Get bitmain read got readlen %d err %d",
-			bitmain->drv->name, bitmain->device_id, readlen, err);
-		total = readlen;
-#endif
-	} else {
-		err = btm_read(bitmain, buf, bufsize);
-		total = err;
-	}
-out:
-	return total;
+
+	err = usb_read_once_timeout(bitmain, (char *)buf, bufsize, &readlen, timeout, ep);
+	applog(LOG_DEBUG, "%s%i: Get bitmain read got readlen %d err %d",
+			  bitmain->drv->name, bitmain->device_id, readlen, err);
+
+	return readlen;
 }
 
 static int bitmain_write(struct cgpu_info *bitmain, char *buf, ssize_t len, int ep)
 {
 	int err, amount;
-	if(opt_bitmain_dev_usb) {
-		err = usb_write(bitmain, buf, len, &amount, ep);
-		applog(LOG_DEBUG, "%s%i: usb_write got err %d", bitmain->drv->name,
-				bitmain->device_id, err);
-
-		if (unlikely(err != 0)) {
-			applog(LOG_ERR, "usb_write error on bitmain_write err=%d", err);
-			return BTM_SEND_ERROR;
-		}
-		if (amount != len) {
-			applog(LOG_ERR, "usb_write length mismatch on bitmain_write amount=%d len=%d", amount, len);
-			return BTM_SEND_ERROR;
-		}
-	} else {
-		int havelen = 0;
-		while(havelen < len) {
-			err = btm_write(bitmain, buf+havelen, len-havelen);
-			if(err < 0) {
-				applog(LOG_DEBUG, "%s%i: btm_write got err %d", bitmain->drv->name,
-						bitmain->device_id, err);
-				applog(LOG_WARNING, "usb_write error on bitmain_write");
-				return BTM_SEND_ERROR;
-			} else {
-				havelen += err;
-			}
-		}
+
+	err = usb_write(bitmain, buf, len, &amount, ep);
+	applog(LOG_DEBUG, "%s%i: usb_write got err %d",
+			  bitmain->drv->name, bitmain->device_id, err);
+
+	if (unlikely(err != 0)) {
+		applog(LOG_ERR, "usb_write error on bitmain_write err=%d", err);
+		return BTM_SEND_ERROR;
+	}
+	if (amount != len) {
+		applog(LOG_ERR, "usb_write length mismatch on bitmain_write "
+				"amount=%d len=%d",
+				amount, (int)len);
+		return BTM_SEND_ERROR;
 	}
+
 	return BTM_SEND_OK;
 }
 
-static int bitmain_send_data(const uint8_t * data, int datalen, struct cgpu_info *bitmain)
+static int bitmain_send_data(const uint8_t *data, int datalen, __maybe_unused struct cgpu_info *bitmain)
 {
-	int delay, ret, ep = C_BITMAIN_SEND;
-	struct bitmain_info *info = NULL;
-	cgtimer_t ts_start;
+	int ret, ep = C_BITMAIN_SEND;
+	//int delay;
+	//struct bitmain_info *info = NULL;
+	//cgtimer_t ts_start;
 
-	if(datalen <= 0) {
+	if (datalen <= 0) {
 		return 0;
 	}
 
-	if(data[0] == BITMAIN_TOKEN_TYPE_TXCONFIG) {
+	if (data[0] == BITMAIN_TOKEN_TYPE_TXCONFIG) {
 		ep = C_BITMAIN_TOKEN_TXCONFIG;
-	} else if(data[0] == BITMAIN_TOKEN_TYPE_TXTASK) {
+	} else if (data[0] == BITMAIN_TOKEN_TYPE_TXTASK) {
 		ep = C_BITMAIN_TOKEN_TXTASK;
-	} else if(data[0] == BITMAIN_TOKEN_TYPE_RXSTATUS) {
+	} else if (data[0] == BITMAIN_TOKEN_TYPE_RXSTATUS) {
 		ep = C_BITMAIN_TOKEN_RXSTATUS;
 	}
 
-	info = bitmain->device_data;
+	//info = bitmain->device_data;
 	//delay = datalen * 10 * 1000000;
 	//delay = delay / info->baud;
 	//delay += 4000;
 
-	if(opt_debug) {
+	if (opt_debug) {
 		applog(LOG_DEBUG, "BitMain: Sent(%d):", datalen);
 		hexdump(data, datalen);
 	}
@@ -714,15 +712,6 @@ static int bitmain_send_data(const uint8_t * data, int datalen, struct cgpu_info
 	return ret;
 }
 
-static bool bitmain_decode_nonce(struct thr_info *thr, struct cgpu_info *bitmain,
-				struct bitmain_info *info, uint32_t nonce, struct work *work)
-{
-	info = bitmain->device_data;
-	//info->matching_work[work->subid]++;
-	applog(LOG_DEBUG, "BitMain: nonce = %08x", nonce);
-	return submit_nonce(thr, work, nonce);
-}
-
 static void bitmain_inc_nvw(struct bitmain_info *info, struct thr_info *thr)
 {
 	applog(LOG_INFO, "%s%d: No matching work - HW error",
@@ -732,31 +721,32 @@ static void bitmain_inc_nvw(struct bitmain_info *info, struct thr_info *thr)
 	info->no_matching_work++;
 }
 
-static inline void record_temp_fan(struct bitmain_info *info, struct bitmain_rxstatus_data *bm, float *temp_avg)
+static inline void record_temp_fan(struct bitmain_info *info, struct bitmain_rxstatus_data *bm, double *temp_avg)
 {
 	int i = 0;
-	*temp_avg = 0;
+
+	*temp_avg = 0.0;
 
 	info->fan_num = bm->fan_num;
-	for(i = 0; i < bm->fan_num; i++) {
+	for (i = 0; i < bm->fan_num; i++) {
 		info->fan[i] = bm->fan[i] * BITMAIN_FAN_FACTOR;
 	}
 	info->temp_num = bm->temp_num;
-	for(i = 0; i < bm->temp_num; i++) {
+	for (i = 0; i < bm->temp_num; i++) {
 		info->temp[i] = bm->temp[i];
 		/*
-		if(bm->temp[i] & 0x80) {
+		if (bm->temp[i] & 0x80) {
 			bm->temp[i] &= 0x7f;
 			info->temp[i] = 0 - ((~bm->temp[i] & 0x7f) + 1);
 		}*/
 		*temp_avg += info->temp[i];
 
-		if(info->temp[i] > info->temp_max) {
+		if (info->temp[i] > info->temp_max) {
 			info->temp_max = info->temp[i];
 		}
 	}
 
-	if(bm->temp_num > 0) {
+	if (bm->temp_num > 0) {
 		*temp_avg = *temp_avg / bm->temp_num;
 		info->temp_avg = *temp_avg;
 	}
@@ -771,16 +761,16 @@ static void bitmain_update_temps(struct cgpu_info *bitmain, struct bitmain_info 
 	record_temp_fan(info, bm, &(bitmain->temp));
 
 	strcpy(msg, "BitMain: ");
-	for(i = 0; i < bm->fan_num; i++) {
-		if(i != 0) {
+	for (i = 0; i < bm->fan_num; i++) {
+		if (i != 0) {
 			strcat(msg, ", ");
 		}
 		sprintf(tmp, "Fan%d: %d/m", i+1, info->fan[i]);
 		strcat(msg, tmp);
 	}
 	strcat(msg, "\t");
-	for(i = 0; i < bm->temp_num; i++) {
-		if(i != 0) {
+	for (i = 0; i < bm->temp_num; i++) {
+		if (i != 0) {
 			strcat(msg, ", ");
 		}
 		sprintf(tmp, "Temp%d: %dC", i+1, info->temp[i]);
@@ -807,62 +797,74 @@ static void bitmain_update_temps(struct cgpu_info *bitmain, struct bitmain_info 
 }
 
 static void bitmain_parse_results(struct cgpu_info *bitmain, struct bitmain_info *info,
-				 struct thr_info *thr, uint8_t *buf, int *offset)
+				  struct thr_info *thr, uint8_t *buf, int *offset)
 {
 	int i, j, n, m, errordiff, spare = BITMAIN_READ_SIZE;
 	uint32_t checkbit = 0x00000000;
 	bool found = false;
 	struct work *work = NULL;
-	char * ob_hex = NULL;
+	//char *ob_hex = NULL;
 
 	for (i = 0; i <= spare; i++) {
-		if(buf[i] == 0xa1) {
+		if (buf[i] == 0xa1) {
 			struct bitmain_rxstatus_data rxstatusdata;
 			applog(LOG_DEBUG, "bitmain_parse_results RxStatus Data");
-			if(*offset < 2) {
+			if (*offset < 2) {
 				return;
 			}
-			if(buf[i+1] > 124) {
-				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxstatus datalen=%d error", buf[i+1]+2);
+			if (buf[i+1] > 124) {
+				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxstatus"
+						" datalen=%d error",
+						buf[i+1]+2);
 				continue;
 			}
-			if(*offset < buf[i+1] + 2) {
+			if (*offset < buf[i+1] + 2) {
 				return;
 			}
-			if(bitmain_parse_rxstatus(buf+i, buf[i+1]+2, &rxstatusdata) != 0) {
-				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxstatus error len=%d", buf[i+1]+2);
+			if (bitmain_parse_rxstatus(buf+i, buf[i+1]+2, &rxstatusdata) != 0) {
+				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxstatus"
+						" error len=%d",
+						buf[i+1]+2);
 			} else {
 				mutex_lock(&info->qlock);
 				info->chain_num = rxstatusdata.chain_num;
 				info->fifo_space = rxstatusdata.fifo_space;
 				info->nonce_error = rxstatusdata.nonce_error;
 				errordiff = info->nonce_error-info->last_nonce_error;
-				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxstatus version=%d chainnum=%d fifospace=%d nonceerror=%d-%d freq=%d chain info:",
-						rxstatusdata.version, info->chain_num, info->fifo_space, info->last_nonce_error, info->nonce_error, info->frequency);
-				for(n = 0; n < rxstatusdata.chain_num; n++) {
+				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxstatus"
+						" version=%d chainnum=%d fifospace=%d"
+						" nonceerror=%d-%d freq=%d chain info:",
+						rxstatusdata.version, info->chain_num,
+						info->fifo_space, info->last_nonce_error,
+						info->nonce_error, info->frequency);
+				for (n = 0; n < rxstatusdata.chain_num; n++) {
 					info->chain_asic_num[n] = rxstatusdata.chain_asic_num[n];
 					info->chain_asic_status[n] = rxstatusdata.chain_asic_status[n];
 					memset(info->chain_asic_status_t[n], 0, 40);
 					j = 0;
-					for(m = 0; m < 32; m++) {
-						if(m%8 == 0 && m != 0) {
+					for (m = 0; m < 32; m++) {
+						if (m%8 == 0 && m != 0) {
 							info->chain_asic_status_t[n][j] = ' ';
 							j++;
 						}
 						checkbit = num2bit(m);
-						if(rxstatusdata.chain_asic_status[n] & checkbit) {
+						if (rxstatusdata.chain_asic_status[n] & checkbit)
 							info->chain_asic_status_t[n][j] = 'o';
-						} else {
+						else
 							info->chain_asic_status_t[n][j] = 'x';
-						}
+
 						j++;
 					}
-					applog(LOG_ERR, "bitmain_parse_rxstatus chain(%d) asic_num=%d asic_status=%08x-%s", n, info->chain_asic_num[n], info->chain_asic_status[n], info->chain_asic_status_t[n]);
+					applog(LOG_ERR, "bitmain_parse_rxstatus chain(%d)"
+							" asic_num=%d asic_status=%08x-%s",
+							n, info->chain_asic_num[n],
+							info->chain_asic_status[n],
+							info->chain_asic_status_t[n]);
 				}
 				mutex_unlock(&info->qlock);
 
-				if(errordiff > 0) {
-					for(j = 0; j < errordiff; j++) {
+				if (errordiff > 0) {
+					for (j = 0; j < errordiff; j++) {
 						bitmain_inc_nvw(info, thr);
 					}
 					mutex_lock(&info->qlock);
@@ -874,32 +876,41 @@ static void bitmain_parse_results(struct cgpu_info *bitmain, struct bitmain_info
 
 			found = true;
 			spare = buf[i+1] + 2 + i;
-			if(spare > *offset) {
-				applog(LOG_ERR, "bitmain_parse_rxresults space(%d) > offset(%d)", spare, *offset);
+			if (spare > *offset) {
+				applog(LOG_ERR, "bitmain_parse_rxresults space(%d) > offset(%d)",
+						spare, *offset);
 				spare = *offset;
 			}
 			break;
-		} else if(buf[i] == 0xa2) {
+		} else if (buf[i] == 0xa2) {
 			struct bitmain_rxnonce_data rxnoncedata;
 			int nonce_num = 0;
 			applog(LOG_DEBUG, "bitmain_parse_results RxNonce Data");
-			if(*offset < 2) {
+			if (*offset < 2) {
 				return;
 			}
-			if(buf[i+1] > 70) {
-				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxnonce datalen=%d error", buf[i+1]+2);
+			if (buf[i+1] > 70) {
+				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxnonce "
+						"datalen=%d error",
+						buf[i+1]+2);
 				continue;
 			}
-			if(*offset < buf[i+1] + 2) {
+			if (*offset < buf[i+1] + 2) {
 				return;
 			}
-			if(bitmain_parse_rxnonce(buf+i, buf[i+1]+2, &rxnoncedata, &nonce_num) != 0) {
-				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxnonce error len=%d", buf[i+1]+2);
+			if (bitmain_parse_rxnonce(buf+i, buf[i+1]+2, &rxnoncedata, &nonce_num) != 0) {
+				applog(LOG_ERR, "bitmain_parse_results bitmain_parse_rxnonce "
+						"error len=%d",
+						buf[i+1]+2);
 			} else {
-				for(j = 0; j < nonce_num; j++) {
-					work = clone_queued_work_byid(bitmain, rxnoncedata.nonces[j].work_id);
-					if(work) {
-						applog(LOG_DEBUG, "bitmain_parse_results nonce find work(%d-%d)(%08x)", work->id, rxnoncedata.nonces[j].work_id, rxnoncedata.nonces[j].nonce);
+				for (j = 0; j < nonce_num; j++) {
+					work = find_queued_work_byid(bitmain, rxnoncedata.nonces[j].work_id);
+					if (work) {
+						applog(LOG_DEBUG, "bitmain_parse_results nonce find "
+								  "work(%"PRIu32"-%"PRIu32")(%08x)",
+								  work->id,
+								  rxnoncedata.nonces[j].work_id,
+								  rxnoncedata.nonces[j].nonce);
 
 						/*ob_hex = bin2hex(work->midstate, 32);
 						applog(LOG_ERR, "work %d midstate: %s", work->id, ob_hex);
@@ -909,37 +920,39 @@ static void bitmain_parse_results(struct cgpu_info *bitmain, struct bitmain_info
 						applog(LOG_ERR, "work %d data2: %s", work->id, ob_hex);
 						free(ob_hex);*/
 
-						if(work->work_block < info->last_work_block) {
-							applog(LOG_ERR, "BitMain: bitmain_parse_rxnonce work(%d) nonce stale", rxnoncedata.nonces[j].work_id);
-						} else {
-							if (bitmain_decode_nonce(thr, bitmain, info, rxnoncedata.nonces[j].nonce, work)) {
-						 		applog(LOG_DEBUG, "bitmain_decode_nonce info->qlock start");
-						 		mutex_lock(&info->qlock);
-						 		info->nonces++;
-								info->auto_nonces++;
-								mutex_unlock(&info->qlock);
-								applog(LOG_DEBUG, "bitmain_decode_nonce info->qlock stop");
-						 	} else {
-						 		//bitmain_inc_nvw(info, thr);
-						 		applog(LOG_ERR, "BitMain: bitmain_decode_nonce error work(%d)", rxnoncedata.nonces[j].work_id);
-						 	}
-						}
-					 	free_work(work);
+						//info->matching_work[work->subid]++;
+						applog(LOG_DEBUG, "BitMain: nonce = %08x",
+								  rxnoncedata.nonces[j].nonce);
+						if (submit_nonce(thr, work, rxnoncedata.nonces[j].nonce)) {
+					 		applog(LOG_DEBUG, "bitmain_decode_nonce ok");
+					 		mutex_lock(&info->qlock);
+					 		info->nonces++;
+							info->auto_nonces++;
+							mutex_unlock(&info->qlock);
+					 	} else {
+					 		//bitmain_inc_nvw(info, thr);
+					 		applog(LOG_ERR, "BitMain: bitmain_decode_nonce "
+									"error work(%"PRIu32")",
+									rxnoncedata.nonces[j].work_id);
+					 	}
 					} else {
 						//bitmain_inc_nvw(info, thr);
-						applog(LOG_ERR, "BitMain: Nonce not find work(%d)", rxnoncedata.nonces[j].work_id);
+						applog(LOG_ERR, "BitMain: Work not found for id (%"PRIu32")",
+								rxnoncedata.nonces[j].work_id);
 					}
 				}
 				mutex_lock(&info->qlock);
 				info->fifo_space = rxnoncedata.fifo_space;
-				applog(LOG_DEBUG, "bitmain_parse_rxnonce fifo space=%d", info->fifo_space);
+				applog(LOG_DEBUG, "bitmain_parse_rxnonce fifo space=%d",
+						  info->fifo_space);
 				mutex_unlock(&info->qlock);
 			}
 
  			found = true;
  			spare = buf[i+1] + 2 + i;
- 			if(spare > *offset) {
- 				applog(LOG_ERR, "bitmain_parse_rxnonce space(%d) > offset(%d)", spare, *offset);
+ 			if (spare > *offset) {
+ 				applog(LOG_ERR, "bitmain_parse_rxnonce space(%d) > offset(%d)",
+						spare, *offset);
  				spare = *offset;
  			}
  			break;
@@ -960,8 +973,7 @@ static void bitmain_parse_results(struct cgpu_info *bitmain, struct bitmain_info
 	memmove(buf, buf + spare, *offset);
 }
 
-static void bitmain_running_reset(struct cgpu_info *bitmain,
-				   struct bitmain_info *info)
+static void bitmain_running_reset(struct cgpu_info *bitmain, struct bitmain_info *info)
 {
 	bitmain->results = 0;
 	info->reset = false;
@@ -971,7 +983,7 @@ static void *bitmain_get_results(void *userdata)
 {
 	struct cgpu_info *bitmain = (struct cgpu_info *)userdata;
 	struct bitmain_info *info = bitmain->device_data;
-	int offset = 0, read_delay = 0, ret = 0;
+	int offset = 0, ret = 0;
 	const int rsize = BITMAIN_FTDI_READSIZE;
 	char readbuf[BITMAIN_READBUF_SIZE];
 	struct thr_info *thr = info->thr;
@@ -988,7 +1000,7 @@ static void *bitmain_get_results(void *userdata)
 
 		if (offset >= (int)BITMAIN_READ_SIZE) {
 			applog(LOG_DEBUG, "======start bitmain_get_results ");
-			bitmain_parse_results(bitmain, info, thr, readbuf, &offset);
+			bitmain_parse_results(bitmain, info, thr, (uint8_t *)readbuf, &offset);
 			applog(LOG_DEBUG, "======stop bitmain_get_results ");
 		}
 
@@ -1018,7 +1030,7 @@ static void *bitmain_get_results(void *userdata)
 
 		if (ret < 1) {
 			errorcount++;
-			if(errorcount > 100) {
+			if (errorcount > 100) {
 				applog(LOG_ERR, "bitmain_read errorcount ret=%d", ret);
 				cgsleep_ms(20);
 				errorcount = 0;
@@ -1037,15 +1049,12 @@ static void *bitmain_get_results(void *userdata)
 	return NULL;
 }
 
+/*
 static void bitmain_set_timeout(struct bitmain_info *info)
 {
 	info->timeout = BITMAIN_TIMEOUT_FACTOR / info->frequency;
 }
-
-static void *bitmain_send_tasks(void *userdata)
-{
-	return NULL;
-}
+*/
 
 static void bitmain_init(struct cgpu_info *bitmain)
 {
@@ -1073,9 +1082,6 @@ static bool bitmain_prepare(struct thr_info *thr)
 	if (pthread_create(&info->read_thr, NULL, bitmain_get_results, (void *)bitmain))
 		quit(1, "Failed to create bitmain read_thr");
 
-	//if (pthread_create(&info->write_thr, NULL, bitmain_send_tasks, (void *)bitmain))
-	//	quit(1, "Failed to create bitmain write_thr");
-
 	bitmain_init(bitmain);
 
 	return true;
@@ -1085,7 +1091,7 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 {
 	uint8_t data[BITMAIN_READBUF_SIZE];
 	struct bitmain_info *info = NULL;
-	int ret = 0, spare = 0;
+	int ret = 0;
 	uint8_t sendbuf[BITMAIN_SENDBUF_SIZE];
 	int readlen = 0;
 	int sendlen = 0;
@@ -1097,7 +1103,7 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 	int eft = 0;
 
 	/* Send reset, then check for result */
-	if(!bitmain) {
+	if (!bitmain) {
 		applog(LOG_WARNING, "bitmain_initialize cgpu_info is null");
 		return -1;
 	}
@@ -1106,7 +1112,7 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 	/* clear read buf */
 	ret = bitmain_read(bitmain, data, BITMAIN_READBUF_SIZE,
 				  BITMAIN_RESET_TIMEOUT, C_BITMAIN_READ);
-	if(ret > 0) {
+	if (ret > 0) {
 		if (opt_debug) {
 			applog(LOG_DEBUG, "BTM%d Clear Read(%d):", bitmain->device_id, ret);
 			hexdump(data, ret);
@@ -1114,7 +1120,7 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 	}
 
 	sendlen = bitmain_set_rxstatus((struct bitmain_rxstatus_token *)sendbuf, 0, 1, 0, 0);
-	if(sendlen <= 0) {
+	if (sendlen <= 0) {
 		applog(LOG_ERR, "bitmain_initialize bitmain_set_rxstatus error(%d)", sendlen);
 		return -1;
 	}
@@ -1124,64 +1130,81 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 		applog(LOG_ERR, "bitmain_initialize bitmain_send_data error");
 		return -1;
 	}
-	while(trycount >= 0) {
-		ret = bitmain_read(bitmain, data+readlen, BITMAIN_READBUF_SIZE, BITMAIN_RESET_TIMEOUT, C_BITMAIN_DATA_RXSTATUS);
-		if(ret > 0) {
+	while (trycount >= 0) {
+		ret = bitmain_read(bitmain, data+readlen, BITMAIN_READBUF_SIZE,
+				   BITMAIN_RESET_TIMEOUT, C_BITMAIN_DATA_RXSTATUS);
+		if (ret > 0) {
 			readlen += ret;
-			if(readlen > BITMAIN_READ_SIZE) {
-				for(i = 0; i < readlen; i++) {
-					if(data[i] == 0xa1) {
+			if (readlen > BITMAIN_READ_SIZE) {
+				for (i = 0; i < readlen; i++) {
+					if (data[i] == 0xa1) {
 						if (opt_debug) {
-							applog(LOG_DEBUG, "%s%d initset: get:", bitmain->drv->name, bitmain->device_id);
+							applog(LOG_DEBUG, "%s%d initset: get:",
+									  bitmain->drv->name,
+									  bitmain->device_id);
 							hexdump(data, readlen);
 						}
-						if(data[i+1] > 124) {
-							applog(LOG_ERR, "bitmain_initialize rxstatus datalen=%d error", data[i+1]+2);
+						if (data[i+1] > 124) {
+							applog(LOG_ERR, "bitmain_initialize rxstatus "
+									"datalen=%d error",
+									data[i+1]+2);
 							continue;
 						}
-						if(readlen-i < data[i+1]+2) {
-							applog(LOG_ERR, "bitmain_initialize rxstatus datalen=%d low", data[i+1]+2);
+						if (readlen-i < data[i+1]+2) {
+							applog(LOG_ERR, "bitmain_initialize rxstatus "
+									"datalen=%d low",
+									data[i+1]+2);
 							continue;
 						}
 						if (bitmain_parse_rxstatus(data+i, data[i+1]+2, &rxstatusdata) != 0) {
-							applog(LOG_ERR, "bitmain_initialize bitmain_parse_rxstatus error");
+							applog(LOG_ERR, "bitmain_initialize "
+									"bitmain_parse_rxstatus error");
 							continue;
 						}
 						info->chain_num = rxstatusdata.chain_num;
 						info->fifo_space = rxstatusdata.fifo_space;
 						info->nonce_error = 0;
 						info->last_nonce_error = 0;
-						applog(LOG_ERR, "bitmain_initialize bitmain_parse_rxstatus version(%d) chain_num(%d) fifo_space(%d) nonce_error(%d) freq=%d",
-								rxstatusdata.version, info->chain_num, info->fifo_space, rxstatusdata.nonce_error, info->frequency);
-						for(i = 0; i < rxstatusdata.chain_num; i++) {
+						applog(LOG_ERR, "bitmain_initialize bitmain_parse_rxstatus "
+								"version(%d) chain_num(%d) fifo_space(%d) "
+								"nonce_error(%d) freq=%d",
+								rxstatusdata.version,
+								info->chain_num,
+								info->fifo_space,
+								rxstatusdata.nonce_error,
+								info->frequency);
+						for (i = 0; i < rxstatusdata.chain_num; i++) {
 							info->chain_asic_num[i] = rxstatusdata.chain_asic_num[i];
 							info->chain_asic_status[i] = rxstatusdata.chain_asic_status[i];
 							memset(info->chain_asic_status_t[i], 0, 40);
 							j = 0;
-							for(m = 0; m < 32; m++) {
-								if(m%8 == 0 && m != 0) {
+							for (m = 0; m < 32; m++) {
+								if (m%8 == 0 && m != 0) {
 									info->chain_asic_status_t[i][j] = ' ';
 									j++;
 								}
 								checkbit = num2bit(m);
-								if(rxstatusdata.chain_asic_status[i] & checkbit) {
+								if (rxstatusdata.chain_asic_status[i] & checkbit)
 									info->chain_asic_status_t[i][j] = 'o';
-								} else {
+								else
 									info->chain_asic_status_t[i][j] = 'x';
-								}
+
 								j++;
 							}
-							applog(LOG_ERR, "bitmain_initialize bitmain_parse_rxstatus chain(%d) asic_num=%d asic_status=%08x-%s",
-									i, info->chain_asic_num[i], info->chain_asic_status[i], info->chain_asic_status_t[i]);
+							applog(LOG_ERR, "bitmain_initialize "
+									"bitmain_parse_rxstatus chain(%d) "
+									"asic_num=%d asic_status=%08x-%s",
+									i, info->chain_asic_num[i],
+									info->chain_asic_status[i],
+									info->chain_asic_status_t[i]);
 						}
 						bitmain_update_temps(bitmain, info, &rxstatusdata);
 						statusok = 1;
 						break;
 					}
 				}
-				if(statusok) {
+				if (statusok)
 					break;
-				}
 			}
 		}
 		trycount--;
@@ -1196,16 +1219,20 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 
 	cgtime(&info->last_status_time);
 
-	if(statusok) {
+	if (statusok) {
 		applog(LOG_ERR, "bitmain_initialize start send txconfig");
-		if(opt_bitmain_hwerror)
+		if (opt_bitmain_hwerror)
 			eft = 1;
 		else
 			eft = 0;
-		sendlen = bitmain_set_txconfig((struct bitmain_txconfig_token *)sendbuf, 1, 1, 1, 1, 1, 0, 1, eft,
-				info->chain_num, info->asic_num, BITMAIN_DEFAULT_FAN_MAX_PWM, info->timeout,
-				info->frequency, BITMAIN_DEFAULT_VOLTAGE, 0, 0, 0x04, info->reg_data);
-		if(sendlen <= 0) {
+
+		sendlen = bitmain_set_txconfig((struct bitmain_txconfig_token *)sendbuf,
+						1, 1, 1, 1, 1, 0, 1, eft,
+						info->chain_num, info->asic_num,
+						BITMAIN_DEFAULT_FAN_MAX_PWM, info->timeout,
+						info->frequency, BITMAIN_DEFAULT_VOLTAGE,
+						0, 0, 0x04, info->reg_data);
+		if (sendlen <= 0) {
 			applog(LOG_ERR, "bitmain_initialize bitmain_set_txconfig error(%d)", sendlen);
 			return -1;
 		}
@@ -1223,100 +1250,7 @@ static int bitmain_initialize(struct cgpu_info *bitmain)
 	return 0;
 }
 
-static void bitmain_usb_init(struct cgpu_info *bitmain)
-{
-	int err, interface;
-
-#ifndef WIN32
-	return;
-#endif
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	interface = usb_interface(bitmain);
-
-	// Reset
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_RESET,
-		FTDI_VALUE_RESET, interface, C_RESET);
-
-	applog(LOG_DEBUG, "%s%i: reset got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	// Set latency
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_LATENCY,
-		BITMAIN_LATENCY, interface, C_LATENCY);
-
-	applog(LOG_DEBUG, "%s%i: latency got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	// Set data
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_DATA,
-				FTDI_VALUE_DATA_BTM, interface, C_SETDATA);
-
-	applog(LOG_DEBUG, "%s%i: data got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	// Set the baud
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_BAUD, FTDI_VALUE_BAUD_BTM,
-				(FTDI_INDEX_BAUD_BTM & 0xff00) | interface,
-				C_SETBAUD);
-
-	applog(LOG_DEBUG, "%s%i: setbaud got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	// Set Modem Control
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
-		FTDI_VALUE_MODEM, interface, C_SETMODEM);
-
-	applog(LOG_DEBUG, "%s%i: setmodemctrl got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	// Set Flow Control
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
-		FTDI_VALUE_FLOW, interface, C_SETFLOW);
-
-	applog(LOG_DEBUG, "%s%i: setflowctrl got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	/* BitMain repeats the following */
-	// Set Modem Control
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_MODEM,
-		FTDI_VALUE_MODEM, interface, C_SETMODEM);
-
-	applog(LOG_DEBUG, "%s%i: setmodemctrl 2 got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-
-	if (bitmain->usbinfo.nodev)
-		return;
-
-	// Set Flow Control
-	err = usb_transfer(bitmain, FTDI_TYPE_OUT, FTDI_REQUEST_FLOW,
-		FTDI_VALUE_FLOW, interface, C_SETFLOW);
-
-	applog(LOG_DEBUG, "%s%i: setflowctrl 2 got err %d",
-		bitmain->drv->name, bitmain->device_id, err);
-}
-
-static struct cgpu_info * bitmain_usb_detect_one(libusb_device *dev, struct usb_find_devices *found)
+static struct cgpu_info *bitmain_detect_one(libusb_device *dev, struct usb_find_devices *found)
 {
 	int baud, chain_num, asic_num, timeout, frequency = 0;
 	uint8_t reg_data[4] = {0};
@@ -1329,7 +1263,7 @@ static struct cgpu_info * bitmain_usb_detect_one(libusb_device *dev, struct usb_
 	if (opt_bitmain_options == NULL)
 		return NULL;
 
-	bitmain = usb_alloc_cgpu(&bitmain_drv, BITMAIN_MINER_THREADS);
+	bitmain = usb_alloc_cgpu(&ants1_drv, BITMAIN_MINER_THREADS);
 
 	baud = BITMAIN_IO_SPEED;
 	chain_num = BITMAIN_DEFAULT_CHAIN_NUM;
@@ -1347,9 +1281,6 @@ static struct cgpu_info * bitmain_usb_detect_one(libusb_device *dev, struct usb_
 	 * all ourselves so set it to std usb type */
 	bitmain->usbdev->usb_type = USB_TYPE_STD;
 
-	/* We have a real BitMain! */
-	bitmain_usb_init(bitmain);
-
 	bitmain->device_data = calloc(sizeof(struct bitmain_info), 1);
 	if (unlikely(!(bitmain->device_data)))
 		quit(1, "Failed to calloc bitmain_info data");
@@ -1416,103 +1347,9 @@ shin:
 	return NULL;
 }
 
-static bool bitmain_detect_one(const char * devpath)
+static void ants1_detect(bool __maybe_unused hotplug)
 {
-	int baud, chain_num, asic_num, timeout, frequency = 0;
-	uint8_t reg_data[4] = {0};
-	int this_option_offset = ++option_offset;
-	struct bitmain_info *info;
-	struct cgpu_info *bitmain;
-	bool configured;
-	int ret;
-
-	if (opt_bitmain_options == NULL)
-		return false;
-
-	bitmain = btm_alloc_cgpu(&bitmain_drv, BITMAIN_MINER_THREADS);
-
-	configured = get_options(this_option_offset, &baud, &chain_num,
-				 &asic_num, &timeout, &frequency, reg_data);
-
-	if (!btm_init(bitmain, opt_bitmain_dev))
-		goto shin;
-	applog(LOG_ERR, "bitmain_detect_one btm init ok");
-
-	bitmain->device_data = calloc(sizeof(struct bitmain_info), 1);
-	if (unlikely(!(bitmain->device_data)))
-		quit(1, "Failed to calloc bitmain_info data");
-	info = bitmain->device_data;
-
-	if (configured) {
-		info->baud = baud;
-		info->chain_num = chain_num;
-		info->asic_num = asic_num;
-		info->timeout = timeout;
-		info->frequency = frequency;
-		memcpy(info->reg_data, reg_data, 4);
-	} else {
-		info->baud = BITMAIN_IO_SPEED;
-		info->chain_num = BITMAIN_DEFAULT_CHAIN_NUM;
-		info->asic_num = BITMAIN_DEFAULT_ASIC_NUM;
-		info->timeout = BITMAIN_DEFAULT_TIMEOUT;
-		info->frequency = BITMAIN_DEFAULT_FREQUENCY;
-		memset(info->reg_data, 0, 4);
-	}
-	info->voltage = BITMAIN_DEFAULT_VOLTAGE;
-
-	info->fan_pwm = BITMAIN_DEFAULT_FAN_MIN_PWM;
-	info->temp_max = 0;
-	/* This is for check the temp/fan every 3~4s */
-	info->temp_history_count = (4 / (float)((float)info->timeout * ((float)1.67/0x32))) + 1;
-	if (info->temp_history_count <= 0)
-		info->temp_history_count = 1;
-
-	info->temp_history_index = 0;
-	info->temp_sum = 0;
-	info->temp_old = 0;
-
-	if (!add_cgpu(bitmain))
-		goto unshin;
-
-	ret = bitmain_initialize(bitmain);
-	applog(LOG_ERR, "bitmain_detect_one stop bitmain_initialize %d", ret);
-	if (ret && !configured)
-		goto unshin;
-
-	info->errorcount = 0;
-
-	applog(LOG_DEBUG, "BitMain Detected: %s "
-	       "(chain_num=%d asic_num=%d timeout=%d frequency=%d)",
-	       bitmain->device_path, info->chain_num, info->asic_num, info->timeout,
-	       info->frequency);
-
-	return true;
-
-unshin:
-	btm_uninit(bitmain);
-
-shin:
-	free(bitmain->device_data);
-	bitmain->device_data = NULL;
-
-	bitmain = usb_free_cgpu(bitmain);
-
-	return false;
-}
-
-static void bitmain_detect(bool __maybe_unused hotplug)
-{
-	applog(LOG_DEBUG, "BTM detect dev: %s", opt_bitmain_dev);
-	if(strlen(opt_bitmain_dev) <= 0) {
-		opt_bitmain_dev_usb = true;
-	} else {
-		opt_bitmain_dev_usb = false;
-	}
-	if(opt_bitmain_dev_usb) {
-		usb_detect(&bitmain_drv, bitmain_usb_detect_one);
-	} else {
-		btm_detect(&bitmain_drv, bitmain_detect_one);
-	}
+	usb_detect(&ants1_drv, bitmain_detect_one);
 }
 
 static void do_bitmain_close(struct thr_info *thr)
@@ -1521,7 +1358,6 @@ static void do_bitmain_close(struct thr_info *thr)
 	struct bitmain_info *info = bitmain->device_data;
 
 	pthread_join(info->read_thr, NULL);
-	pthread_join(info->write_thr, NULL);
 	bitmain_running_reset(bitmain, info);
 
 	info->no_matching_work = 0;
@@ -1536,12 +1372,12 @@ static void get_bitmain_statline_before(char *buf, size_t bufsiz, struct cgpu_in
 	int i = 0;
 
 	/* Find the lowest fan speed of the ASIC cooling fans. */
-	for(i = 0; i < info->fan_num; i++) {
+	for (i = 0; i < info->fan_num; i++) {
 		if (info->fan[i] >= 0 && info->fan[i] < lowfan)
 			lowfan = info->fan[i];
 	}
 
-	tailsprintf(buf, bufsiz, "%2d/%3dC %04dR | ", info->temp_avg, info->temp_max, lowfan);
+	tailsprintf(buf, bufsiz, "%2d/%3dC %04dR", info->temp_avg, info->temp_max, lowfan);
 }
 
 /* We use a replacement algorithm to only remove references to work done from
@@ -1561,7 +1397,7 @@ static bool bitmain_fill(struct cgpu_info *bitmain)
 
 	applog(LOG_DEBUG, "BTM bitmain_fill start--------");
 	mutex_lock(&info->qlock);
-	if(info->fifo_space <= 0) {
+	if (info->fifo_space <= 0) {
 		applog(LOG_DEBUG, "BTM bitmain_fill fifo space empty--------");
 		ret = true;
 		goto out_unlock;
@@ -1571,44 +1407,51 @@ static bool bitmain_fill(struct cgpu_info *bitmain)
 	} else {
 		ret = false;
 	}
-	while(info->fifo_space > 0) {
+	while (info->fifo_space > 0) {
 		neednum = info->fifo_space<8?info->fifo_space:8;
 		queuednum = bitmain->queued;
-		applog(LOG_DEBUG, "BTM: Work task queued(%d) fifo space(%d) needsend(%d)", queuednum, info->fifo_space, neednum);
-		if(queuednum < neednum) {
-			while(true) {
+		applog(LOG_DEBUG, "BTM: Work task queued(%d) fifo space(%d) needsend(%d)",
+				  queuednum, info->fifo_space, neednum);
+		if (queuednum < neednum) {
+			while (true) {
 				work = get_queued(bitmain);
 				if (unlikely(!work)) {
 					break;
 				} else {
-					applog(LOG_DEBUG, "BTM get work queued number:%d neednum:%d", queuednum, neednum);
+					applog(LOG_DEBUG, "BTM get work queued number:%d neednum:%d",
+							  queuednum, neednum);
 					subid = bitmain->queued++;
 					work->subid = subid;
 					slot = bitmain->work_array + subid;
 					if (slot > BITMAIN_ARRAY_SIZE) {
-						applog(LOG_DEBUG, "bitmain_fill array cyc %d", BITMAIN_ARRAY_SIZE);
+						applog(LOG_DEBUG, "bitmain_fill array cyc %d",
+								  BITMAIN_ARRAY_SIZE);
 						slot = 0;
 					}
 					if (likely(bitmain->works[slot])) {
-						applog(LOG_DEBUG, "bitmain_fill work_completed %d", slot);
+						applog(LOG_DEBUG, "bitmain_fill work_completed %d",
+								  slot);
 						work_completed(bitmain, bitmain->works[slot]);
 					}
 					bitmain->works[slot] = work;
 					queuednum++;
-					if(queuednum >= neednum) {
+					if (queuednum >= neednum) {
 						break;
 					}
 				}
 			}
 		}
-		if(queuednum < BITMAIN_MAX_DEAL_QUEUE_NUM) {
-			if(queuednum < neednum) {
-				applog(LOG_DEBUG, "BTM: No enough work to send, queue num=%d", queuednum);
+		if (queuednum < BITMAIN_MAX_DEAL_QUEUE_NUM) {
+			if (queuednum < neednum) {
+				applog(LOG_DEBUG, "BTM: No enough work to send, queue num=%d",
+						  queuednum);
 				break;
 			}
 		}
 		sendnum = queuednum < neednum ? queuednum : neednum;
-		sendlen = bitmain_set_txtask(sendbuf, &(info->last_work_block), bitmain->works, BITMAIN_ARRAY_SIZE, bitmain->work_array, sendnum, &sendcount);
+		sendlen = bitmain_set_txtask(sendbuf, &(info->last_work_block), bitmain->works,
+					     BITMAIN_ARRAY_SIZE, bitmain->work_array, sendnum,
+					     &sendcount);
 		bitmain->queued -= sendnum;
 		info->send_full_space += sendnum;
 		if (bitmain->queued < 0)
@@ -1632,7 +1475,9 @@ static bool bitmain_fill(struct cgpu_info *bitmain)
 				senderror = 1;
 				if (info->errorcount > 1000) {
 					info->errorcount = 0;
-					applog(LOG_ERR, "%s%d: Device disappeared, shutting down thread", bitmain->drv->name, bitmain->device_id);
+					applog(LOG_ERR, "%s%d: Device disappeared,"
+							" shutting down thread",
+							bitmain->drv->name, bitmain->device_id);
 					bitmain->shutdown = true;
 				}
 				break;
@@ -1649,7 +1494,7 @@ static bool bitmain_fill(struct cgpu_info *bitmain)
 out_unlock:
 	cgtime(&now);
 	timediff = now.tv_sec - info->last_status_time.tv_sec;
-	if(timediff < 0) timediff = -timediff;
+	if (timediff < 0) timediff = -timediff;
 
 	if (now.tv_sec - info->last_status_time.tv_sec > BITMAIN_SEND_STATUS_TIME) {
 		applog(LOG_DEBUG, "BTM: Send RX Status Token fifo_space(%d) timediff(%d)",
@@ -1667,7 +1512,9 @@ out_unlock:
 				senderror = 1;
 				if (info->errorcount > 1000) {
 					info->errorcount = 0;
-					applog(LOG_ERR, "%s%d: Device disappeared, shutting down thread", bitmain->drv->name, bitmain->device_id);
+					applog(LOG_ERR, "%s%d: Device disappeared,"
+							" shutting down thread",
+							bitmain->drv->name, bitmain->device_id);
 					bitmain->shutdown = true;
 				}
 			} else {
@@ -1678,12 +1525,12 @@ out_unlock:
 			}
 		}
 	}
-	if(info->send_full_space > BITMAIN_SEND_FULL_SPACE) {
+	if (info->send_full_space > BITMAIN_SEND_FULL_SPACE) {
 		info->send_full_space = 0;
 		ret = true;
 	}
 	mutex_unlock(&info->qlock);
-	if(senderror) {
+	if (senderror) {
 		ret = true;
 		cgsleep_prepare_r(&ts_start);
 		cgsleep_ms_r(&ts_start, 50);
@@ -1698,8 +1545,6 @@ static int64_t bitmain_scanhash(struct thr_info *thr)
 	const int chain_num = info->chain_num;
 	struct timeval now, then, tdiff;
 	int64_t hash_count, us_timeout;
-	struct timespec abstime;
-	int ret;
 
 	/* Half nonce range */
 	us_timeout = 0x80000000ll / info->asic_num / info->frequency;
@@ -1707,10 +1552,7 @@ static int64_t bitmain_scanhash(struct thr_info *thr)
 	tdiff.tv_usec = us_timeout - (tdiff.tv_sec * 1000000);
 	cgtime(&now);
 	timeradd(&now, &tdiff, &then);
-	abstime.tv_sec = then.tv_sec;
-	abstime.tv_nsec = then.tv_usec * 1000;
 
-	applog(LOG_DEBUG, "bitmain_scanhash info->qlock start");
 	mutex_lock(&info->qlock);
 	hash_count = 0xffffffffull * (uint64_t)info->nonces;
 	bitmain->results += info->nonces + info->idle;
@@ -1720,7 +1562,6 @@ static int64_t bitmain_scanhash(struct thr_info *thr)
 		bitmain->results--;
 	info->nonces = info->idle = 0;
 	mutex_unlock(&info->qlock);
-	applog(LOG_DEBUG, "bitmain_scanhash info->qlock stop");
 
 	/* Check for nothing but consecutive bad results or consistently less
 	 * results than we should be getting and reset the FPGA if necessary */
@@ -1743,12 +1584,12 @@ static int64_t bitmain_scanhash(struct thr_info *thr)
 static void bitmain_flush_work(struct cgpu_info *bitmain)
 {
 	struct bitmain_info *info = bitmain->device_data;
-	int i = 0;
+	//int i = 0;
 
 	mutex_lock(&info->qlock);
 	/* Will overwrite any work queued */
 	applog(LOG_ERR, "bitmain_flush_work queued=%d array=%d", bitmain->queued, bitmain->work_array);
-	if(bitmain->queued > 0) {
+	if (bitmain->queued > 0) {
 		if (bitmain->work_array + bitmain->queued > BITMAIN_ARRAY_SIZE) {
 			bitmain->work_array = bitmain->work_array + bitmain->queued-BITMAIN_ARRAY_SIZE;
 		} else {
@@ -1757,7 +1598,7 @@ static void bitmain_flush_work(struct cgpu_info *bitmain)
 	}
 	bitmain->queued = 0;
 	//bitmain->work_array = 0;
-	//for(i = 0; i < BITMAIN_ARRAY_SIZE; i++) {
+	//for (i = 0; i < BITMAIN_ARRAY_SIZE; i++) {
 	//	bitmain->works[i] = NULL;
 	//}
 	//pthread_cond_signal(&info->qcond);
@@ -1768,8 +1609,7 @@ static struct api_data *bitmain_api_stats(struct cgpu_info *cgpu)
 {
 	struct api_data *root = NULL;
 	struct bitmain_info *info = cgpu->device_data;
-	char buf[64];
-	int i = 0;
+	//int i = 0;
 	double hwp = (cgpu->hw_errors + cgpu->diff1) ?
 			(double)(cgpu->hw_errors) / (double)(cgpu->hw_errors + cgpu->diff1) : 0;
 
@@ -1827,17 +1667,6 @@ static void bitmain_shutdown(struct thr_info *thr)
 	do_bitmain_close(thr);
 }
 
-char *set_bitmain_dev(char *arg)
-{
-	if(arg == NULL || strlen(arg) <= 0) {
-		memcpy(opt_bitmain_dev, 0, 256);
-	} else {
-		strncpy(opt_bitmain_dev, arg, 256);
-	}
-	applog(LOG_DEBUG, "BTM set device: %s", opt_bitmain_dev);
-	return NULL;
-}
-
 char *set_bitmain_fan(char *arg)
 {
 	int val1, val2, ret;
@@ -1877,12 +1706,14 @@ char *set_bitmain_freq(char *arg)
 
 	return NULL;
 }
+#endif
 
-struct device_drv bitmain_drv = {
-	.drv_id = DRIVER_bitmain,
-	.dname = "Bitmain",
-	.name = "BTM",
-	.drv_detect = bitmain_detect,
+struct device_drv ants1_drv = {
+	.drv_id = DRIVER_ants1,
+	.dname = "BitmainAntS1",
+	.name = "ANT",
+	.drv_detect = ants1_detect,
+#ifdef LINUX
 	.thread_prepare = bitmain_prepare,
 	.hash_work = hash_queued_work,
 	.queue_full = bitmain_fill,
@@ -1892,4 +1723,5 @@ struct device_drv bitmain_drv = {
 	.get_statline_before = get_bitmain_statline_before,
 	.reinit_device = bitmain_init,
 	.thread_shutdown = bitmain_shutdown,
+#endif
 };
diff --git a/driver-bitmain.h b/driver-bitmain.h
index 33d9773..febbf4b 100644
--- a/driver-bitmain.h
+++ b/driver-bitmain.h
@@ -1,6 +1,7 @@
 /*
  * Copyright 2013 BitMain project
  * Copyright 2013 BitMain <xlc1985@126.com>
+ * Copyright 2014 Andrew Smith
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -11,7 +12,7 @@
 #ifndef BITMAIN_H
 #define BITMAIN_H
 
-#ifdef USE_BITMAIN
+#ifdef USE_ANT_S1
 
 #include "util.h"
 
@@ -197,7 +198,6 @@ struct bitmain_info {
 
 	struct thr_info *thr;
 	pthread_t read_thr;
-	pthread_t write_thr;
 	pthread_mutex_t lock;
 	pthread_mutex_t qlock;
 	pthread_cond_t qcond;
@@ -232,7 +232,6 @@ struct bitmain_info {
 ASSERT1(sizeof(uint32_t) == 4);
 
 extern struct bitmain_info **bitmain_info;
-extern char opt_bitmain_dev[256];
 extern int opt_bitmain_temp;
 extern int opt_bitmain_overheat;
 extern int opt_bitmain_fan_min;
@@ -240,9 +239,8 @@ extern int opt_bitmain_fan_max;
 extern int opt_bitmain_freq_min;
 extern int opt_bitmain_freq_max;
 extern bool opt_bitmain_auto;
-extern char *set_bitmain_dev(char *arg);
 extern char *set_bitmain_fan(char *arg);
 extern char *set_bitmain_freq(char *arg);
 
-#endif /* USE_BITMAIN */
+#endif /* USE_ANT_S1 */
 #endif	/* BITMAIN_H */
diff --git a/miner.h b/miner.h
index e0e7e52..90d3989 100644
--- a/miner.h
+++ b/miner.h
@@ -244,6 +244,7 @@ static inline int fsync (int fd)
 	DRIVER_ADD_COMMAND(drillbit) \
 	DRIVER_ADD_COMMAND(bab) \
 	DRIVER_ADD_COMMAND(minion) \
+	DRIVER_ADD_COMMAND(ants1) \
 	DRIVER_ADD_COMMAND(avalon2) \
 	DRIVER_ADD_COMMAND(avalon)
 
@@ -430,7 +431,7 @@ struct cgpu_info {
 	struct cg_usb_info usbinfo;
 	bool blacklisted;
 #endif
-#if defined(USE_AVALON) || defined(USE_AVALON2)
+#if defined(USE_AVALON) || defined(USE_AVALON2) || defined(USE_ANT_S1)
 	struct work **works;
 	int work_array;
 	int queued;
@@ -988,6 +989,10 @@ extern char *opt_bab_options;
 #ifdef USE_BITMINE_A1
 extern char *opt_bitmine_a1_options;
 #endif
+#ifdef USE_ANT_S1
+extern char *opt_bitmain_options;
+extern bool opt_bitmain_hwerror;
+#endif
 #ifdef USE_USBUTILS
 extern char *opt_usb_select;
 extern int opt_usbdump;
@@ -1305,7 +1310,7 @@ struct work {
 	int		gbt_txns;
 
 	unsigned int	work_block;
-	int		id;
+	uint32_t	id;
 	UT_hash_handle	hh;
 
 	double		work_difficulty;
@@ -1382,6 +1387,8 @@ extern struct work *get_queue_work(struct thr_info *thr, struct cgpu_info *cgpu,
 extern struct work *__find_work_bymidstate(struct work *que, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen);
 extern struct work *find_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen);
 extern struct work *clone_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen);
+extern struct work *__find_work_byid(struct work *que, uint32_t id);
+extern struct work *find_queued_work_byid(struct cgpu_info *cgpu, uint32_t id);
 extern void __work_completed(struct cgpu_info *cgpu, struct work *work);
 extern int age_queued_work(struct cgpu_info *cgpu, double secs);
 extern void work_completed(struct cgpu_info *cgpu, struct work *work);
diff --git a/usbutils.h b/usbutils.h
index c47e41e..4a40475 100644
--- a/usbutils.h
+++ b/usbutils.h
@@ -405,7 +405,14 @@ struct cg_usb_info {
 	USB_ADD_COMMAND(C_MCP_SETSPISETTING, "MCPSetSPISetting") \
 	USB_ADD_COMMAND(C_MCP_GETSPISETTING, "MCPGetSPISetting") \
 	USB_ADD_COMMAND(C_MCP_SPITRANSFER, "MCPSPITransfer") \
-	USB_ADD_COMMAND(C_MCP_SPICANCEL, "MCPSPICancel")
+	USB_ADD_COMMAND(C_MCP_SPICANCEL, "MCPSPICancel") \
+	USB_ADD_COMMAND(C_BITMAIN_SEND, "BitmainSend") \
+	USB_ADD_COMMAND(C_BITMAIN_READ, "BitmainRead") \
+	USB_ADD_COMMAND(C_BITMAIN_TOKEN_TXCONFIG, "BitmainTokenTxConfig") \
+	USB_ADD_COMMAND(C_BITMAIN_TOKEN_TXTASK, "BitmainTokenTxTask") \
+	USB_ADD_COMMAND(C_BITMAIN_TOKEN_RXSTATUS, "BitmainTokenRxStatus") \
+	USB_ADD_COMMAND(C_BITMAIN_DATA_RXSTATUS, "BitmainDataRxStatus") \
+	USB_ADD_COMMAND(C_BITMAIN_DATA_RXNONCE, "BitmainDataRxNonce")
 
 /* Create usb_cmds enum from USB_PARSE_COMMANDS macro */
 enum usb_cmds {