thodg/cgminer

diff --git a/Makefile.am b/Makefile.am
index 4127368..ce7f11a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -110,11 +110,17 @@ if HAS_COINTERRA
 cgminer_SOURCES += driver-cointerra.c driver-cointerra.h
 endif
 
-if HAS_SPONDOOLIES
+if HAS_SP10
 cgminer_SOURCES += driver-spondoolies.c driver-spondoolies.h \
 		   mg_proto_parser.c mg_proto_parser.h
 endif
 
+
+if HAS_SP30
+cgminer_SOURCES += driver-spondoolies-sp30.c driver-spondoolies-sp30.h \
+		   mg_proto_parser_sp30.c mg_proto_parser_sp30.h
+endif
+
 if HAS_BAB
 cgminer_SOURCES += driver-bab.c
 endif
diff --git a/api.c b/api.c
index c4bfcd9..edd1016 100644
--- a/api.c
+++ b/api.c
@@ -30,7 +30,7 @@
 	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_ANT_S1) || defined(USE_ANT_S2) || defined(USE_SPONDOOLIES) || \
+	defined(USE_ANT_S1) || defined(USE_ANT_S2) || defined(USE_SP10) || defined(USE_SP30) || \
 	defined(USE_ICARUS)
 #define HAVE_AN_ASIC 1
 #endif
@@ -200,9 +200,13 @@ static const char *DEVICECODE = ""
 #ifdef USE_COINTERRA
 			"CTA "
 #endif
-#ifdef USE_SPONDOOLIES
+#ifdef USE_SP10
 			"SPN "
 #endif
+#ifdef USE_SP30
+      "S30 "
+#endif
+
 
 			"";
 
diff --git a/cgminer.c b/cgminer.c
index bf063eb..b8f5ef3 100644
--- a/cgminer.c
+++ b/cgminer.c
@@ -76,10 +76,14 @@ char *curly = ":D";
 #include "driver-bflsc.h"
 #endif
 
-#ifdef USE_SPONDOOLIES
+#ifdef USE_SP10
 #include "driver-spondoolies.h"
 #endif
 
+#ifdef USE_SP30
+#include "driver-spondoolies-sp30.h"
+#endif
+
 
 #ifdef USE_BITFURY
 #include "driver-bitfury.h"
@@ -1723,9 +1727,13 @@ static char *opt_verusage_and_exit(const char *extra)
 #ifdef USE_BITMINE_A1
 		"Bitmine.A1 "
 #endif
-#ifdef USE_SPONDOOLIES
+#ifdef USE_SP10
 		"spondoolies "
 #endif
+#ifdef USE_SP30
+        "sp30 "
+#endif
+
 		"mining support.\n"
 		, packagename);
 	printf("%s", opt_usage(opt_argv0, extra));
diff --git a/configure.ac b/configure.ac
index 2cacafe..3d9ab9f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -314,16 +314,29 @@ AM_CONDITIONAL([HAS_MODMINER], [test x$modminer = xyes])
 
 
 
-spondoolies="no"
+sp10="no"
 
-AC_ARG_ENABLE([spondoolies],
-	[AC_HELP_STRING([--enable-spondoolies],[Compile support for Spondoolies (default disabled)])],
-	[spondoolies=$enableval]
+AC_ARG_ENABLE([sp10],
+	[AC_HELP_STRING([--enable-sp10],[Compile support for Spondoolies SP10 (default disabled)])],
+	[sp10=$enableval]
 	)
-if test "x$spondoolies" = xyes; then
-	AC_DEFINE([USE_SPONDOOLIES], [1], [Defined to 1 if Spondoolies support is wanted])
+if test "x$sp10" = xyes; then
+	AC_DEFINE([USE_SP10], [1], [Defined to 1 if Spondoolies SP10 support is wanted])
 fi
-AM_CONDITIONAL([HAS_SPONDOOLIES], [test x$spondoolies = xyes])
+AM_CONDITIONAL([HAS_SP10], [test x$sp10 = xyes])
+
+
+
+sp30="no"
+
+AC_ARG_ENABLE([sp30],
+	[AC_HELP_STRING([--enable-sp30],[Compile support for Spondoolies SP30 (default disabled)])],
+	[sp30=$enableval]
+	)
+if test "x$sp30" = xyes; then
+	AC_DEFINE([USE_SP30], [1], [Defined to 1 if SP30 support is wanted])
+fi
+AM_CONDITIONAL([HAS_SP30], [test x$sp30 = xyes])
 
 
 curses="auto"
@@ -590,12 +603,20 @@ else
 	echo "  Cointerra.ASICs......: Disabled"
 fi
 
-if test "x$spondoolies" = xyes; then
-	echo "  Spondoolies.ASICs....: Enabled"
+if test "x$sp10" = xyes; then
+	echo "  Spond-sp10.ASICs.....: Enabled"
 else
-	echo "  Spondoolies.ASICs....: Disabled"
+	echo "  Spond-sp10.ASICs.....: Disabled"
 fi
 
+
+if test "x$sp30" = xyes; then
+	echo "  Spond-sp30.ASICs.....: Enabled"
+else
+	echo "  Spond-sp30.ASICs.....: Disabled"
+fi
+
+
 if test "x$bitmine_A1" = xyes; then
 	echo "  Bitmine-A1.ASICs.....: Enabled"
 else
@@ -638,7 +659,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$ants1$ants2$spondoolies" = xnononononononononononononononononono; then
+if test "x$avalon$avalon2$bab$bflsc$bitforce$bitfury$hashfast$icarus$klondike$knc$modminer$drillbit$minion$cointerra$bitmine_A1$ants1$ants2$sp10$sp30" = xnonononononononononononononononononono; then
 	AC_MSG_ERROR([No mining configured in])
 fi
 
diff --git a/driver-spondoolies-sp30.c b/driver-spondoolies-sp30.c
new file mode 100644
index 0000000..737b9f9
--- /dev/null
+++ b/driver-spondoolies-sp30.c
@@ -0,0 +1,442 @@
+/*
+ * Copyright 2014 Con Kolivas <kernel@kolivas.org>
+ * Copyright 2014 Zvi (Zvisha) Shteingart - Spondoolies-tech.com
+ *
+ * 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
+ * Software Foundation; either version 3 of the License, or (at your option)
+ * any later version.  See COPYING for more details.
+ */
+
+/*
+ This driver communicates the job requests via Unix socket to the minergate
+ process, that is responsible for controlling the Spondoolies Dawson SP10 miner.
+
+ The jobs sent each with unique ID and returned asynchronously in one of the next
+ transactions. REQUEST_PERIOD and REQUEST_SIZE define the communication rate with minergate.
+*/
+
+#include <float.h>
+#include <limits.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <strings.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <assert.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <string.h>
+#include <math.h>
+
+#include "config.h"
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include "compat.h"
+#include "miner.h"
+#include "mg_proto_parser_sp30.h"
+#include "driver-spondoolies-sp30.h"
+
+#ifdef WORDS_BIGENDIAN
+#  define swap32tobe(out, in, sz)  ((out == in) ? (void)0 : memmove(out, in, sz))
+#  define LOCAL_swap32be(type, var, sz)  ;
+#  define swap32tole(out, in, sz)  swap32yes(out, in, sz)
+#  define LOCAL_swap32le(type, var, sz)  LOCAL_swap32(type, var, sz)
+#else
+#  define swap32tobe(out, in, sz)  swap32yes(out, in, sz)
+#  define LOCAL_swap32be(type, var, sz)  LOCAL_swap32(type, var, sz)
+#  define swap32tole(out, in, sz)  ((out == in) ? (void)0 : memmove(out, in, sz))
+#  define LOCAL_swap32le(type, var, sz)  ;
+#endif
+
+static inline void swap32yes(void *out, const void *in, size_t sz)
+{
+	size_t swapcounter;
+
+	for (swapcounter = 0; swapcounter < sz; ++swapcounter)
+		(((uint32_t*)out)[swapcounter]) = swab32(((uint32_t*)in)[swapcounter]);
+}
+
+static void send_minergate_pkt(const minergate_req_packet_sp30* mp_req, minergate_rsp_packet_sp30* mp_rsp,
+			       int  socket_fd)
+{
+	int nbytes, nwrote, nread;
+
+	nbytes = sizeof(minergate_req_packet_sp30);
+	nwrote = write(socket_fd, (const void *)mp_req, nbytes);
+	if (unlikely(nwrote != nbytes))
+		_quit(-1);
+	nbytes = sizeof(minergate_rsp_packet_sp30);
+	nread = read(socket_fd, (void *)mp_rsp, nbytes);
+	if (unlikely(nread != nbytes))
+		_quit(-1);
+	assert(mp_rsp->magic == 0xcaf4);
+}
+
+static bool spondoolies_prepare(struct thr_info *thr)
+{
+	struct cgpu_info *spondoolies_sp30 = thr->cgpu;
+	struct timeval now;
+
+	assert(spondoolies_sp30);
+	cgtime(&now);
+	/* FIXME: Vladik */
+#if NEED_FIX
+	get_datestamp(spondoolies_sp30->init, &now);
+#endif
+	return true;
+}
+
+static int init_socket(void)
+{
+  printf("Init\n");
+	int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
+	struct sockaddr_un address;
+
+	if (socket_fd < 0) {
+		printf("socket() failed\n");
+		perror("Err:");
+		return 0;
+	}
+
+	/* start with a clean address structure */
+	memset(&address, 0, sizeof(struct sockaddr_un));
+
+	address.sun_family = AF_UNIX;
+	sprintf(address.sun_path, MINERGATE_SOCKET_FILE_SP30);
+
+	if(connect(socket_fd, (struct sockaddr *) &address, sizeof(struct sockaddr_un))) {
+		printf("connect() failed\n");
+		perror("Err:");
+		return 0;
+	}
+
+	return socket_fd;
+}
+
+static bool spondoolies_flush_queue(struct spond_adapter* a, bool flush_queue)
+{
+	if (!a->parse_resp) {
+		static int i = 0;
+
+		if (i++ % 10 == 0 && a->works_in_minergate_and_pending_tx + a->works_pending_tx != a->works_in_driver)
+			printf("%d + %d != %d\n", a->works_in_minergate_and_pending_tx, a->works_pending_tx,a->works_in_driver);
+		assert(a->works_in_minergate_and_pending_tx + a->works_pending_tx == a->works_in_driver);
+		send_minergate_pkt(a->mp_next_req,  a->mp_last_rsp, a->socket_fd);
+		if (flush_queue)
+			a->mp_next_req->mask |= 0x02;
+		else
+			a->mp_next_req->mask &= ~0x02;
+
+		a->mp_next_req->req_count = 0;
+		a->parse_resp = 1;
+		a->works_in_minergate_and_pending_tx += a->works_pending_tx;
+		a->works_pending_tx = 0;
+	}
+	return true;
+}
+
+static void spondoolies_detect(__maybe_unused bool hotplug)
+{
+	struct cgpu_info *cgpu = calloc(1, sizeof(*cgpu));
+	struct device_drv *drv = &sp30_drv;
+	struct spond_adapter *a;
+
+#if NEED_FIX
+	nDevs = 1;
+#endif
+
+	assert(cgpu);
+	cgpu->drv = drv;
+	cgpu->deven = DEV_ENABLED;
+	cgpu->threads = 1;
+	cgpu->device_data = calloc(sizeof(struct spond_adapter), 1);
+	if (unlikely(!(cgpu->device_data)))
+		quit(1, "Failed to calloc cgpu_info data");
+	a = cgpu->device_data;
+	a->cgpu = (void *)cgpu;
+	a->adapter_state = ADAPTER_STATE_OPERATIONAL;
+	a->mp_next_req = allocate_minergate_packet_req_sp30(0xca, 0xfe);
+	a->mp_last_rsp = allocate_minergate_packet_rsp_sp30(0xca, 0xfe);
+
+	pthread_mutex_init(&a->lock, NULL);
+	a->socket_fd = init_socket();
+	if (a->socket_fd < 1) {
+		printf("Error connecting to minergate server!");
+		_quit(-1);
+	}
+
+	assert(add_cgpu(cgpu));
+	// Clean MG socket
+	spondoolies_flush_queue(a, true);
+	spondoolies_flush_queue(a, true);
+	spondoolies_flush_queue(a, true);
+	applog(LOG_DEBUG, "SPOND spondoolies_detect done");
+}
+
+static struct api_data *spondoolies_api_stats(struct cgpu_info *cgpu)
+{
+	struct spond_adapter *a = cgpu->device_data;
+	struct api_data *root = NULL;
+
+	root = api_add_int(root, "ASICs total rate", &a->temp_rate, false);
+	root = api_add_int(root, "Temparature rear", &a->rear_temp, false);
+	root = api_add_int(root, "Temparature front", &a->front_temp, false);
+
+	return root;
+}
+
+#if 0
+static unsigned char get_leading_zeroes(const unsigned char *target)
+{
+	unsigned char leading = 0;
+	int first_non_zero_chr;
+	uint8_t m;
+
+	for (first_non_zero_chr = 31; first_non_zero_chr >= 0; first_non_zero_chr--) {
+		if (target[first_non_zero_chr] == 0)
+			leading += 8;
+		else
+			break;
+	}
+
+	// j = first non-zero
+	m = target[first_non_zero_chr];
+	while ((m & 0x80) == 0) {
+		leading++;
+		m = m << 1;
+	}
+	return leading;
+}
+#endif
+
+static void spondoolies_shutdown(__maybe_unused struct thr_info *thr)
+{
+}
+
+static void fill_minergate_request(minergate_do_job_req_sp30* work, struct work *cg_work, int max_offset)
+{
+	uint32_t x[64/4];
+	uint64_t wd;
+
+	memset(work, 0, sizeof(minergate_do_job_req_sp30));
+	//work->
+	LOCAL_swap32le(unsigned char, cg_work->midstate, 32/4)
+	LOCAL_swap32le(unsigned char, cg_work->data+64, 64/4)
+	swap32yes(x, cg_work->data + 64, 64/4);
+	memcpy(work->midstate, cg_work->midstate, 32);
+	work->mrkle_root = ntohl(x[0]);
+	work->timestamp  = ntohl(x[1]);
+	work->difficulty = ntohl(x[2]);
+	//work->leading_zeroes = get_leading_zeroes(cg_work->target);
+	// Is there no better way to get leading zeroes?
+	work->leading_zeroes = 30;
+	wd = round(cg_work->work_difficulty);
+	while (wd) {
+		work->leading_zeroes++;
+		wd = wd >> 1;
+	}
+	//printf("%d %d\n",work->leading_zeroes, (int)round(cg_work->work_difficulty));
+	work->work_id_in_sw = cg_work->subid;
+	work->ntime_limit = max_offset;
+  printf("ID:%d, TS:%x\n",work->work_id_in_sw,work->timestamp);
+	//work->ntime_offset = ntime_offset;
+}
+
+// returns true if queue full.
+static struct timeval last_force_queue = {0};
+
+static bool spondoolies_queue_full(struct cgpu_info *cgpu)
+{
+	// Only once every 1/10 second do work.
+	struct spond_adapter* a = cgpu->device_data;
+	int next_job_id, i;
+	struct timeval tv;
+	struct work *work;
+	unsigned int usec;
+	bool ret = false;
+
+	mutex_lock(&a->lock);
+	assert(a->works_pending_tx <= REQUEST_SIZE);
+
+	gettimeofday(&tv, NULL);
+
+	usec = (tv.tv_sec-last_force_queue.tv_sec) * 1000000;
+	usec += (tv.tv_usec-last_force_queue.tv_usec);
+
+	if ((usec >= REQUEST_PERIOD) || (a->reset_mg_queue == 2) ||
+	    ((a->reset_mg_queue == 1) && (a->works_pending_tx == REQUEST_SIZE))) {
+		spondoolies_flush_queue(a, (a->reset_mg_queue == 2));
+		if (a->reset_mg_queue)
+			a->reset_mg_queue--;
+		last_force_queue = tv;
+	}
+
+	// see if we have enough jobs
+	if (a->works_pending_tx == REQUEST_SIZE) {
+		ret = true;
+		goto return_unlock;
+	}
+
+	// see if can take 1 more job.
+	next_job_id = (a->current_job_id + 1) % MAX_JOBS_IN_MINERGATE_SP30;
+	if (a->my_jobs[next_job_id].cgminer_work) {
+		ret = true;
+		goto return_unlock;
+	}
+	work = get_queued(cgpu);
+	if (!work) {
+		cgsleep_ms(10);
+		goto return_unlock;
+	}
+
+	work->thr = cgpu->thr[0];
+	work->thr_id = cgpu->thr[0]->id;
+	assert(work->thr);
+
+	// Create 5 works using ntime increment
+	a->current_job_id = next_job_id;
+	work->subid = a->current_job_id;
+	// Get pointer for the request
+	a->my_jobs[a->current_job_id].cgminer_work = work;
+	a->my_jobs[a->current_job_id].state = SPONDWORK_STATE_IN_BUSY;
+
+
+	int max_ntime_roll = (work->drv_rolllimit < MAX_NROLES) ? work->drv_rolllimit : MAX_NROLES;
+	minergate_do_job_req_sp30* pkt_job =  &a->mp_next_req->req[a->works_pending_tx];
+	fill_minergate_request(pkt_job, work, max_ntime_roll);
+	a->works_in_driver++;
+	a->works_pending_tx++;
+	a->mp_next_req->req_count++;
+	a->my_jobs[a->current_job_id].merkle_root = pkt_job->mrkle_root;
+
+return_unlock:
+	mutex_unlock(&a->lock);
+
+	return ret;
+}
+
+static void spond_poll_stats(struct cgpu_info *spond, struct spond_adapter *a)
+{
+	FILE *fp = fopen("/var/run/mg_rate_temp", "r");
+
+	if (!fp) {
+		applog(LOG_DEBUG, "SPOND unable to open mg_rate_temp");
+		a->temp_rate = a->rear_temp = a->front_temp = 0;
+	} else {
+		int ret = fscanf(fp, "%d %d %d", &a->temp_rate, &a->rear_temp, &a->front_temp);
+
+		if (ret != 3)
+			a->temp_rate = a->rear_temp = a->front_temp = 0;
+		fclose(fp);
+	}
+	applog(LOG_DEBUG, "SPOND poll_stats rate: %d rear: %d front: %d",
+	       a->temp_rate, a->rear_temp, a->front_temp);
+	/* Use the rear temperature as the dev temperature for now */
+	spond->temp = a->rear_temp;
+}
+
+// Return completed work to submit_nonce() and work_completed() 
+// struct timeval last_force_queue = {0};  
+static int64_t spond_scanhash(struct thr_info *thr)
+{
+	struct cgpu_info *cgpu = thr->cgpu;
+	struct spond_adapter *a = cgpu->device_data;
+	int64_t ghashes = 0;
+	cgtimer_t cgt;
+	time_t now_t;
+
+	cgsleep_prepare_r(&cgt);
+	now_t = time(NULL);
+	/* Poll stats only once per second */
+	if (now_t != a->last_stats) {
+		a->last_stats = now_t;
+		spond_poll_stats(cgpu, a);
+	}
+
+	if (a->parse_resp) {
+		int array_size, i, j;
+
+		mutex_lock(&a->lock);
+		ghashes = (a->mp_last_rsp->gh_div_10_rate);
+		ghashes = ghashes  * 10000 * REQUEST_PERIOD;
+		array_size = a->mp_last_rsp->rsp_count;
+		for (i = 0; i < array_size; i++) { // walk the jobs
+			int job_id;
+
+			minergate_do_job_rsp_sp30* work = a->mp_last_rsp->rsp + i;
+			job_id = work->work_id_in_sw;
+			if ((a->my_jobs[job_id].cgminer_work)) {
+				if (a->my_jobs[job_id].merkle_root == work->mrkle_root) {
+					assert(a->my_jobs[job_id].state == SPONDWORK_STATE_IN_BUSY);
+					a->works_in_minergate_and_pending_tx--;
+					a->works_in_driver--;
+
+					if (work->winner_nonce) {
+						bool __maybe_unused ok;
+						struct work *cg_work = a->my_jobs[job_id].cgminer_work;
+						ok = submit_noffset_nonce(cg_work->thr, cg_work, work->winner_nonce, work->ntime_offset);
+						printf("OK on %d (+%d), none=%x = %d\n",
+              work->work_id_in_sw, work->ntime_offset, htole32(work->winner_nonce), ok);
+						a->wins++;
+					}
+            
+					//printf("%d ntime_clones = %d\n",job_id,a->my_jobs[job_id].ntime_clones);
+
+					//printf("Done with %d\n", job_id);
+					if (work->job_complete) {
+  					work_completed(a->cgpu, a->my_jobs[job_id].cgminer_work);
+  					a->good++;
+  					a->my_jobs[job_id].cgminer_work = NULL;
+  					a->my_jobs[job_id].state = SPONDWORK_STATE_EMPTY;
+					}
+
+				} else {
+					a->bad++;
+					printf("Dropping minergate old job id=%d mrkl=%x my-mrkl=%x\n",
+					       job_id, a->my_jobs[job_id].merkle_root, work->mrkle_root);
+				}
+			} else {
+				a->empty++;
+				printf("No cgminer job (id:%d res:%d)!\n",job_id, work->res);
+			}
+		}
+		mutex_unlock(&a->lock);
+
+		a->parse_resp = 0;
+	}
+	cgsleep_ms_r(&cgt, 40);
+
+	return ghashes;
+}
+
+// Remove all work from queue
+static void spond_flush_work(struct cgpu_info *cgpu)
+{
+	struct spond_adapter *a = cgpu->device_data;
+
+	mutex_lock(&a->lock);
+	a->reset_mg_queue = 2;
+	mutex_unlock(&a->lock);
+}
+
+struct device_drv sp30_drv = {
+	.drv_id = DRIVER_sp30,
+	.dname = "Sp30",
+	.name = "S30",
+	.max_diff = 64.0, // Limit max diff to get some nonces back regardless
+	.drv_detect = spondoolies_detect,
+	.get_api_stats = spondoolies_api_stats,
+	.thread_prepare = spondoolies_prepare,
+	.thread_shutdown = spondoolies_shutdown,
+	.hash_work = hash_queued_work,
+	.queue_full = spondoolies_queue_full,
+	.scanwork = spond_scanhash,
+	.flush_work = spond_flush_work,
+};
diff --git a/driver-spondoolies-sp30.h b/driver-spondoolies-sp30.h
new file mode 100644
index 0000000..a3c63e7
--- /dev/null
+++ b/driver-spondoolies-sp30.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2014 Con Kolivas <kernel@kolivas.org>
+ * Copyright 2014 Zvi Shteingart - Spondoolies-tech.com
+ *
+ * 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
+ * Software Foundation; either version 3 of the License, or (at your option)
+ * any later version.  See COPYING for more details.
+ */
+
+#ifndef SPONDA_HFILE
+#define SPONDA_HFILE
+
+#include "miner.h"
+#include "mg_proto_parser_sp30.h"
+
+
+typedef enum adapter_state {
+	ADAPTER_STATE_INIT,
+	ADAPTER_STATE_OPERATIONAL,
+} ADAPTER_STATE;
+
+typedef enum spond_work_state {
+	SPONDWORK_STATE_EMPTY,
+	SPONDWORK_STATE_IN_BUSY,
+} SPONDWORK_STATE;
+
+#define MAX_JOBS_IN_MINERGATE_SP30 MINERGATE_TOTAL_QUEUE_SP30 // 1.5 sec worth of jobs
+#define MAX_NROLES 60 
+
+typedef struct {
+	struct work      *cgminer_work;
+	SPONDWORK_STATE  state;
+	uint32_t         merkle_root;
+	time_t           start_time;
+	int              job_id;
+} spond_driver_work_sp30;
+
+struct spond_adapter {
+	pthread_mutex_t lock;
+	ADAPTER_STATE adapter_state;
+	void *cgpu;
+
+	// Statistics
+	int wins;
+	int good;
+	int empty;
+	int bad;
+	int overflow;
+	// state
+	int works_in_driver;
+	int works_in_minergate_and_pending_tx;
+	int works_pending_tx;
+	int socket_fd;
+	int reset_mg_queue;  // 2=reset, 1=fast send, 0=nada
+	int current_job_id;
+	int parse_resp;
+	minergate_req_packet_sp30* mp_next_req;
+	minergate_rsp_packet_sp30* mp_last_rsp;
+	spond_driver_work_sp30 my_jobs[MAX_JOBS_IN_MINERGATE_SP30];
+
+	// Temperature statistics
+	int temp_rate;
+	int rear_temp;
+	int front_temp;
+
+	// Last second we polled stats
+	time_t last_stats;
+};
+
+// returns non-zero if needs to change ASICs.
+int spond_one_sec_timer_scaling(struct spond_adapter *a, int t);
+int spond_do_scaling(struct spond_adapter *a);
+
+extern void one_sec_spondoolies_watchdog(int uptime);
+
+#define REQUEST_PERIOD (100000)  //  times per second - in usec
+#define REQUEST_SIZE   10      //  jobs per request
+
+#endif
diff --git a/mg_proto_parser_sp30.c b/mg_proto_parser_sp30.c
new file mode 100644
index 0000000..6d5fdc0
--- /dev/null
+++ b/mg_proto_parser_sp30.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2014 Zvi (Zvisha) Shteingart - Spondoolies-tech.com
+ *
+ * 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
+ * Software Foundation; either version 3 of the License, or (at your option)
+ * any later version.  See COPYING for more details.
+ */
+
+/*
+ This file holds functions needed for minergate packet parsing/creation
+*/
+
+#include "mg_proto_parser_sp30.h"
+#include "assert.h"
+//#include "spond_debug.h"
+
+#ifndef passert
+#define passert assert
+#endif
+
+minergate_req_packet_sp30 *allocate_minergate_packet_req_sp30(uint8_t requester_id,
+                                                        uint8_t request_id) {
+  minergate_req_packet_sp30 *p =
+      (minergate_req_packet_sp30 *)malloc(sizeof(minergate_req_packet_sp30));
+  p->requester_id = requester_id;
+  p->req_count = 0;
+  p->protocol_version = MINERGATE_PROTOCOL_VERSION_SP30;
+  p->request_id = request_id;
+  p->magic = 0xcaf4;
+  p->mask = 0;
+  return p;
+}
+
+minergate_rsp_packet_sp30 *allocate_minergate_packet_rsp_sp30(uint8_t requester_id,
+                                                    uint8_t request_id) {
+
+  minergate_rsp_packet_sp30 *p =
+      (minergate_rsp_packet_sp30 *)malloc(sizeof(minergate_rsp_packet_sp30));
+  p->requester_id = requester_id;
+  p->rsp_count = 0;
+  p->protocol_version = MINERGATE_PROTOCOL_VERSION_SP30;
+  p->request_id = request_id;
+  p->magic = 0xcaf4;
+  p->gh_div_10_rate= 0;
+  return p;
+}
diff --git a/mg_proto_parser_sp30.h b/mg_proto_parser_sp30.h
new file mode 100644
index 0000000..128c12d
--- /dev/null
+++ b/mg_proto_parser_sp30.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2014 Zvi (Zvisha) Shteingart - Spondoolies-tech.com
+ *
+ * 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
+ * Software Foundation; either version 3 of the License, or (at your option)
+ * any later version.  See COPYING for more details.
+ *
+ * Note that changing this SW will void your miners guaranty
+ */
+
+
+#ifndef ____MINERGATE_LIB30_H___
+#define ____MINERGATE_LIB30_H___
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/types.h>
+#include <linux/spi/spidev.h>
+#include <netinet/in.h>
+
+
+#define MINERGATE_PROTOCOL_VERSION_SP30 30
+#define MINERGATE_SOCKET_FILE_SP30 "/tmp/connection_pipe_sp30"
+
+typedef enum {
+  MINERGATE_DATA_ID_DO_JOB_REQ_SP30 = 5,
+  MINERGATE_DATA_ID_DO_JOB_RSP_SP30 = 6,
+} MINERGATE_DATA_ID_SP30;
+
+typedef struct {
+  uint32_t work_id_in_sw;
+  uint32_t difficulty;
+  uint32_t timestamp;
+  uint32_t mrkle_root;
+  uint32_t midstate[8];
+  uint8_t leading_zeroes;
+  uint8_t ntime_limit; // max ntime - should be 60
+  uint8_t resr2;
+  uint8_t resr1;
+} minergate_do_job_req_sp30;
+
+#define MAX_REQUESTS_SP30 30
+#define MAX_RESPONDS_SP30 60
+#define MINERGATE_TOTAL_QUEUE_SP30 20
+
+typedef struct {
+  uint32_t work_id_in_sw;
+  uint32_t mrkle_root; // to validate
+  uint32_t winner_nonce;  
+  uint8_t  ntime_offset;
+  uint8_t res; // 0 = done, 1 = overflow, 2 = dropped bist
+  uint8_t job_complete; 
+  uint8_t resrv2; 
+} minergate_do_job_rsp_sp30;
+
+typedef struct {
+  uint8_t requester_id;
+  uint8_t request_id;
+  uint8_t protocol_version;
+	uint8_t mask; // 0x01 = first request, 0x2 = drop old work
+  uint16_t magic;   // 0xcaf4
+  uint16_t req_count;
+  minergate_do_job_req_sp30 req[MAX_REQUESTS_SP30]; // array of requests
+} minergate_req_packet_sp30;
+
+typedef struct {
+  uint8_t requester_id;
+  uint8_t request_id;
+  uint8_t protocol_version;
+  uint8_t gh_div_10_rate;
+  uint16_t magic;   // 0xcaf4
+  uint16_t rsp_count;
+  minergate_do_job_rsp_sp30 rsp[MAX_RESPONDS_SP30]; // array of responces
+} minergate_rsp_packet_sp30;
+
+minergate_req_packet_sp30* allocate_minergate_packet_req_sp30(uint8_t requester_id,uint8_t request_id);
+minergate_rsp_packet_sp30* allocate_minergate_packet_rsp_sp30(uint8_t requester_id,uint8_t request_id);
+
+#endif
diff --git a/miner.h b/miner.h
index 74c8345..0cba7ed 100644
--- a/miner.h
+++ b/miner.h
@@ -244,7 +244,8 @@ static inline int fsync (int fd)
 	DRIVER_ADD_COMMAND(drillbit) \
 	DRIVER_ADD_COMMAND(bab) \
 	DRIVER_ADD_COMMAND(minion) \
-	DRIVER_ADD_COMMAND(spondoolies)
+	DRIVER_ADD_COMMAND(spondoolies) \
+	DRIVER_ADD_COMMAND(sp30)
 
 #define DRIVER_PARSE_COMMANDS(DRIVER_ADD_COMMAND) \
 	FPGA_PARSE_COMMANDS(DRIVER_ADD_COMMAND) \